LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Djb2HashNoCase64(char const*)
uint64_t Djb2HashNoCase64(const char *str_)
{
  const uint8_t *str = (const uint8_t *) str_;
  uint64_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 $0x30, %rsp
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 0x7a0a
imulq $0x21, -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x7f50
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x79cc
cmpq $0x0, -0x18(%rbp)
je 0x7a1b
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7a26
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0x7a26
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Log(t2::LogLevel, char const*, ...)
void Log(LogLevel level, const char* fmt, ...)
{
  if (s_LogFlags & level)
  {
    const char* prefix = "?";

    switch (level)
    {
      case kError   : prefix = "E"; break;
      case kWarning : prefix = "W"; break;
      case kInfo    : prefix = "I"; break;
      case kDebug   : prefix = "D"; break;
      case kSpam    : prefix = "S"; break;
      default       : break;
    }
    fprintf(stderr, "[%s] ", prefix);

    va_list args;
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);

    fprintf(stderr, "\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x7a98
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x278bf(%rip), %eax     # 0x2f380
andl -0x4(%rbp), %eax
cmpl $0x0, %eax
je 0x7bb8
leaq 0x1c35c(%rip), %rax     # 0x23e30
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0xe8(%rbp)
subl $0xf, %eax
ja 0x7b43
movq -0xe8(%rbp), %rax
leaq 0x1c2b3(%rip), %rcx     # 0x23dac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c54e(%rip), %rax     # 0x24057
movq %rax, -0x18(%rbp)
jmp 0x7b45
leaq 0x1c31c(%rip), %rax     # 0x23e32
movq %rax, -0x18(%rbp)
jmp 0x7b45
leaq 0x1d520(%rip), %rax     # 0x25043
movq %rax, -0x18(%rbp)
jmp 0x7b45
leaq 0x1c304(%rip), %rax     # 0x23e34
movq %rax, -0x18(%rbp)
jmp 0x7b45
leaq 0x1c4fb(%rip), %rax     # 0x24038
movq %rax, -0x18(%rbp)
jmp 0x7b45
jmp 0x7b45
movq 0x27484(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1c2dc(%rip), %rsi     # 0x23e36
movb $0x0, %al
callq 0x3470
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x27444(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3450
leaq -0x30(%rbp), %rax
movq 0x27429(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
leaq 0x1bd34(%rip), %rsi     # 0x238e5
movb $0x0, %al
callq 0x3470
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::NextPowerOfTwo(unsigned int)
uint32_t NextPowerOfTwo(uint32_t val)
{
  uint32_t mask = val - 1;

  mask |= mask >> 16;
  mask |= mask >> 8;
  mask |= mask >> 4;
  mask |= mask >> 2;
  mask |= mask >> 1;

  uint32_t pow2 = mask + 1;
  CHECK(pow2 >= val);
  CHECK((pow2 & mask) == 0);
  CHECK((pow2 & ~mask) == pow2);

  return pow2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x4, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x2, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7cf6
jmp 0x7cf8
jmp 0x7cfa
jmp 0x7cfc
jmp 0x7cfe
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::GetCpuCount()
int GetCpuCount()
{
#if defined(TUNDRA_WIN32)
  SYSTEM_INFO si;
  GetSystemInfo(&si);
  return (int) si.dwNumberOfProcessors;
#elif defined(TUNDRA_LINUX)
  long nprocs_max = sysconf(_SC_NPROCESSORS_ONLN);
  if (nprocs_max < 0)
    CroakErrno("couldn't get CPU count");
  return (int) nprocs_max;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x54, %edi
callq 0x3220
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x7e3b
leaq 0x1c07b(%rip), %rdi     # 0x23eaf
movb $0x0, %al
callq 0x7680
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::CountTrailingZeroes(unsigned int)
int CountTrailingZeroes(uint32_t v)
{
  v &= -int32_t(v);

  int bit_index = 32;

  if (v)
    --bit_index;

  if (v & 0x0000ffff) bit_index -= 16;
  if (v & 0x00ff00ff) bit_index -= 8;
  if (v & 0x0f0f0f0f) bit_index -= 4;
  if (v & 0x33333333) bit_index -= 2;
  if (v & 0x55555555) bit_index -= 1;

  return bit_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
subl -0x4(%rbp), %eax
andl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x20, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x7e78
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x0, %eax
je 0x7e8e
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
cmpl $0x0, %eax
je 0x7ea4
movl -0x8(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
cmpl $0x0, %eax
je 0x7eba
movl -0x8(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x33333333, %eax       # imm = 0x33333333
cmpl $0x0, %eax
je 0x7ed0
movl -0x8(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x55555555, %eax       # imm = 0x55555555
cmpl $0x0, %eax
je 0x7ee6
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.hpp
// Function: t2::FoldCase(int)
inline int FoldCase(int c)
{
  // This generates branch-free code on GCC, Clang and MSVC
  unsigned int x = (unsigned int) c - 'A';
  int d = c + 0x20;
  return (x < 26 ? d : c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
subl $0x41, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $0x20, %eax
movl %eax, -0xc(%rbp)
cmpl $0x1a, -0x8(%rbp)
jae 0x7f77
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x7f7d
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::WriteCommonStringPtr(t2::BinarySegment*, t2::BinarySegment*, char const*, t2::HashTable<t2::CommonStringRecord, 0u>*, t2::MemAllocLinear*)
void WriteCommonStringPtr(BinarySegment* segment, BinarySegment* str_seg, const char* ptr, HashTable<CommonStringRecord, 0>* table, MemAllocLinear* scratch)
{
  uint32_t hash = Djb2Hash(ptr);
  CommonStringRecord* r;
  if (nullptr == (r = HashTableLookup(table, hash, ptr)))
  {
    CommonStringRecord r;
    r.m_Pointer = BinarySegmentPosition(str_seg);
    HashTableInsert(table, hash, ptr, r);
    BinarySegmentWriteStringData(str_seg, ptr);
    BinarySegmentWritePointer(segment, r.m_Pointer);
  }
  else
  {
    BinarySegmentWritePointer(segment, r->m_Pointer);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7860
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xb740
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x803c
movq -0x10(%rbp), %rdi
callq 0x20e20
movl %eax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0xb7a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb800
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x68(%rbp), %esi
movq -0x60(%rbp), %rdx
callq 0x20db0
jmp 0x805f
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x78(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movl -0x78(%rbp), %esi
movq -0x70(%rbp), %rdx
callq 0x20db0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::FindStringValue(t2::JsonValue const*, char const*, char const*)
static const char* FindStringValue(const JsonValue* obj, const char* key, const char* default_value = nullptr)
{
  if (JsonValue::kObject != obj->m_Type)
    return default_value;

  const JsonValue *node = obj->Find(key);

  if (!node)
    return default_value;

  if (JsonValue::kString != node->m_Type)
    return default_value;

  return static_cast<const JsonStringValue*>(node)->m_String;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
je 0x848b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x84d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x84ad
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x84d0
movq -0x28(%rbp), %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
je 0x84c4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x84d0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::FindArrayValue(t2::JsonObjectValue const*, char const*)
static const JsonArrayValue* FindArrayValue(const JsonObjectValue* obj, const char* key)
{
  if (obj == nullptr)
    return nullptr;

  const JsonValue *node = obj->Find(key);

  if (!node)
    return nullptr;
  if (JsonValue::kArray != node->m_Type)
    return nullptr;
  return static_cast<const JsonArrayValue*>(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8501
movq $0x0, -0x8(%rbp)
jmp 0x8542
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8523
movq $0x0, -0x8(%rbp)
jmp 0x8542
movq -0x20(%rbp), %rcx
movl $0x3, %eax
cmpl (%rcx), %eax
je 0x853a
movq $0x0, -0x8(%rbp)
jmp 0x8542
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::CreateDagFromJsonData(char*, char const*)
static bool CreateDagFromJsonData(char* json_memory, const char* dag_fn)
{
  MemAllocHeap heap;
  HeapInit(&heap);

  MemAllocLinear alloc;
  MemAllocLinear scratch;

  LinearAllocInit(&alloc, &heap, MB(128), "json alloc");
  LinearAllocInit(&scratch, &heap, MB(64), "json scratch");

  char error_msg[1024];

  bool result = false;

  const JsonValue* value = JsonParse(json_memory, &alloc, &scratch, error_msg);

  if (value)
  {
    if (const JsonObjectValue* obj = value->AsObject())
    {
      BinaryWriter writer;
      BinaryWriterInit(&writer, &heap);

      result = CompileDag(obj, &writer, &heap, &scratch);

      result = result && BinaryWriterFlush(&writer, dag_fn);

      BinaryWriterDestroy(&writer);
    }
    else
    {
      Log(kError, "bad JSON structure");
    }
  }
  else
  {
    Log(kError, "failed to parse JSON: %s", error_msg);
  }

  LinearAllocDestroy(&scratch);
  LinearAllocDestroy(&alloc);

  t2::HeapDestroy(&heap);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x18920
leaq -0x50(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x8000000, %edx        # imm = 0x8000000
leaq 0x1b623(%rip), %rcx     # 0x24083
callq 0x189e0
leaq -0x88(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x4000000, %edx        # imm = 0x4000000
leaq 0x1b612(%rip), %rcx     # 0x2408e
callq 0x189e0
movb $0x0, -0x491(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0x490(%rbp), %rcx
callq 0x17280
movq %rax, -0x4a0(%rbp)
cmpq $0x0, -0x4a0(%rbp)
je 0x8b63
movq -0x4a0(%rbp), %rdi
callq 0xb850
movq %rax, -0x4a8(%rbp)
cmpq $0x0, -0x4a8(%rbp)
je 0x8b4e
leaq -0x4c8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x20e50
movq -0x4a8(%rbp), %rdi
leaq -0x4c8(%rbp), %rsi
leaq -0x11(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x8d90
andb $0x1, %al
movb %al, -0x491(%rbp)
xorl %eax, %eax
testb $0x1, -0x491(%rbp)
movb %al, -0x4c9(%rbp)
je 0x8b32
movq -0x10(%rbp), %rsi
leaq -0x4c8(%rbp), %rdi
callq 0x20f60
movb %al, -0x4c9(%rbp)
movb -0x4c9(%rbp), %al
andb $0x1, %al
movb %al, -0x491(%rbp)
leaq -0x4c8(%rbp), %rdi
callq 0x20e80
jmp 0x8b61
movl $0x1, %edi
leaq 0x1b541(%rip), %rsi     # 0x2409b
movb $0x0, %al
callq 0x7a60
jmp 0x8b7d
leaq -0x490(%rbp), %rdx
movl $0x1, %edi
leaq 0x1b538(%rip), %rsi     # 0x240ae
movb $0x0, %al
callq 0x7a60
leaq -0x88(%rbp), %rdi
callq 0x18ac0
leaq -0x50(%rbp), %rdi
callq 0x18ac0
leaq -0x11(%rbp), %rdi
callq 0x18930
movb -0x491(%rbp), %al
andb $0x1, %al
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::GenerateIdeIntegrationFiles(char const*, int, char const**)
bool GenerateIdeIntegrationFiles(const char* build_file, int argc, const char** argv)
{
  MemAllocHeap heap;
  HeapInit(&heap);

  Buffer<char> args;
  BufferInit(&args);
  CreateCommandLine(&heap, &args, argc, argv);

  // Run DAG generator.
  bool result = RunExternalTool("generate-ide-files %s %s", build_file, args.m_Storage);

  BufferDestroy(&args, &heap);
  t2::HeapDestroy(&heap);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x18920
leaq -0x38(%rbp), %rdi
callq 0xb940
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x19(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8c30
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x1b3e3(%rip), %rdi     # 0x23fdb
movb $0x0, %al
callq 0x8790
andb $0x1, %al
movb %al, -0x39(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0xb970
leaq -0x19(%rbp), %rdi
callq 0x18930
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::CreateCommandLine(t2::MemAllocHeap*, t2::Buffer<char>*, int, char const**)
static void CreateCommandLine(MemAllocHeap* heap, Buffer<char>* args, int argc, const char** argv)
{
  for (int i = 0; i < argc; ++i)
  {
    if (i > 0)
      BufferAppendOne(args, heap, ' ');

    const size_t arglen = strlen(argv[i]);
    const bool has_spaces = nullptr != strchr(argv[i], ' ');

    if (has_spaces)
      BufferAppendOne(args, heap, '"');

    BufferAppend(args, heap, argv[i], arglen);

    if (has_spaces)
      BufferAppendOne(args, heap, '"');
  }

  BufferAppendOne(args, heap, '\0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8d0a
cmpl $0x0, -0x24(%rbp)
jle 0x8c72
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x20, %edx
callq 0xbf40
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3150
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x20, %esi
callq 0x3130
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
setne %al
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x8cc5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x22, %edx
callq 0xbf40
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rcx
callq 0xbf80
testb $0x1, -0x31(%rbp)
je 0x8cfa
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x22, %edx
callq 0xbf40
jmp 0x8cfc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8c4e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0xbf40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::GenerateTemplateFiles(int, char const**)
bool GenerateTemplateFiles(int argc, const char** argv)
{
  MemAllocHeap heap;
  HeapInit(&heap);

  Buffer<char> args;
  BufferInit(&args);
  CreateCommandLine(&heap, &args, argc, argv);

  // Run DAG generator.
  bool result = RunExternalTool("create-template-file %s", args.m_Storage);

  BufferDestroy(&args, &heap);
  t2::HeapDestroy(&heap);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x18920
leaq -0x30(%rbp), %rdi
callq 0xb940
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0x11(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8c30
movq -0x30(%rbp), %rsi
leaq 0x1b294(%rip), %rdi     # 0x23ff4
movb $0x0, %al
callq 0x8790
andb $0x1, %al
movb %al, -0x31(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0xb970
leaq -0x11(%rbp), %rdi
callq 0x18930
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::WriteStringPtr(t2::BinarySegment*, t2::BinarySegment*, char const*)
static void WriteStringPtr(BinarySegment* seg, BinarySegment *str_seg, const char* text)
{
  if (text)
  {
    BinarySegmentWritePointer(seg, BinarySegmentPosition(str_seg));
    BinarySegmentWriteStringData(str_seg, text);
  }
  else
  {
    BinarySegmentWriteNullPointer(seg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb072
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e20
movq -0x30(%rbp), %rdi
movl %eax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x20db0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb800
jmp 0xb07b
movq -0x8(%rbp), %rdi
callq 0xbba0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::FindObjectValue(t2::JsonObjectValue const*, char const*)
static const JsonObjectValue* FindObjectValue(const JsonObjectValue* obj, const char* key)
{
  const JsonValue *node = obj->Find(key);
  if (!node)
    return nullptr;
  if (JsonValue::kObject != node->m_Type)
    return nullptr;
  return static_cast<const JsonObjectValue*>(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb0c2
movq $0x0, -0x8(%rbp)
jmp 0xb0e1
movq -0x20(%rbp), %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
je 0xb0d9
movq $0x0, -0x8(%rbp)
jmp 0xb0e1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::WriteStrHashArray(t2::BinarySegment*, t2::BinarySegment*, t2::BinarySegment*, t2::JsonArrayValue const*)
static bool WriteStrHashArray(
    BinarySegment* main_seg,
    BinarySegment* aux_seg,
    BinarySegment* str_seg,
    const JsonArrayValue* strings)
{
  BinarySegmentWriteInt32(main_seg, (int) strings->m_Count);
  BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));
  for (size_t i = 0, count = strings->m_Count; i < count; ++i)
  {
    const char* str = strings->m_Values[i]->GetString();
    if (!str)
      return false;
    WriteStringPtr(aux_seg, str_seg, str);
  }
  BinarySegmentWritePointer(main_seg, BinarySegmentPosition(aux_seg));
  for (size_t i = 0, count = strings->m_Count; i < count; ++i)
  {
    const char* str = strings->m_Values[i]->GetString();
    uint32_t hash = Djb2Hash(str);
    BinarySegmentWriteUint32(aux_seg, hash);
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0xbb00
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e20
movq -0x88(%rbp), %rdi
movl %eax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x20db0
movq $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xb1b2
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbb30
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0xb193
movb $0x0, -0x1(%rbp)
jmp 0xb241
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xb020
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xb160
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e20
movq -0x90(%rbp), %rdi
movl %eax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movl -0x60(%rbp), %esi
movq -0x58(%rbp), %rdx
callq 0x20db0
movq $0x0, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x70(%rbp), %rax
jae 0xb23d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbb30
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x7860
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x7c(%rbp), %esi
callq 0xbaa0
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0xb1f4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::FindIntValue(t2::JsonObjectValue const*, char const*, long)
static int64_t FindIntValue(const JsonObjectValue* obj, const char* key, int64_t def_value)
{
  const JsonValue *node = obj->Find(key);
  if (!node)
    return def_value;
  if (JsonValue::kNumber != node->m_Type)
    return def_value;
  return (int64_t) static_cast<const JsonNumberValue*>(node)->m_Number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xb286
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb2ab
movq -0x28(%rbp), %rcx
movl $0x5, %eax
cmpl (%rcx), %eax
je 0xb29d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb2ab
movq -0x28(%rbp), %rax
cvttsd2si 0x8(%rax), %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/DagGenerator.cpp
// Function: t2::WriteNodeArray(t2::BinarySegment*, t2::BinarySegment*, t2::JsonArrayValue const*, int const*)
static bool WriteNodeArray(BinarySegment* top_seg, BinarySegment* data_seg, const JsonArrayValue* ints, const int32_t remap_table[])
{
  BinarySegmentWriteInt32(top_seg, (int) ints->m_Count);
  BinarySegmentWritePointer(top_seg, BinarySegmentPosition(data_seg));

  for (size_t i = 0, count = ints->m_Count; i < count; ++i)
  {
    if (const JsonNumberValue* num = ints->m_Values[i]->AsNumber())
    {
      int index = remap_table[(int) num->m_Number];
      BinarySegmentWriteInt32(data_seg, index);
    }
    else
      return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0xbb00
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e20
movq -0x60(%rbp), %rdi
movl %eax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x20db0
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xb38b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbb60
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xb375
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
cvttsd2si 0x8(%rcx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
movl -0x54(%rbp), %esi
callq 0xbb00
jmp 0xb37b
movb $0x0, -0x1(%rbp)
jmp 0xb38f
jmp 0xb37d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xb327
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::GetBoolean(t2::JsonObjectValue const*, char const*)
static bool GetBoolean(const JsonObjectValue* obj, const char* name)
{
  if (const JsonValue* val = obj->Find(name))
  {
    if (const JsonBooleanValue* b = val->AsBoolean())
    {
      return b->m_Boolean;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb9d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb3ec
movq -0x20(%rbp), %rdi
callq 0xbca0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb3ea
movq -0x28(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xb3f0
jmp 0xb3ec
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/DagGenerator.cpp
// Function: t2::WriteFileArray(t2::BinarySegment*, t2::BinarySegment*, t2::BinarySegment*, t2::JsonArrayValue const*)
static bool WriteFileArray(
    BinarySegment* seg,
    BinarySegment* ptr_seg,
    BinarySegment* str_seg,
    const JsonArrayValue* files)
{
  if (!files || 0 == files->m_Count)
  {
    BinarySegmentWriteInt32(seg, 0);
    BinarySegmentWriteNullPointer(seg);
    return true;
  }

  BinarySegmentWriteInt32(seg, (int) files->m_Count);
  BinarySegmentWritePointer(seg, BinarySegmentPosition(ptr_seg));

  for (size_t i = 0, count = files->m_Count; i < count; ++i)
  {
    const JsonStringValue *path = files->m_Values[i]->AsString();
    if (!path)
      return false;

    PathBuffer pathbuf;
    PathInit(&pathbuf, path->m_String);

    char cleaned_path[kMaxPathLength];
    PathFormat(cleaned_path, &pathbuf);

    WriteStringPtr(ptr_seg, str_seg, cleaned_path);
    BinarySegmentWriteUint32(ptr_seg, Djb2HashPath(cleaned_path));
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb56e
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0xb58b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xbb00
movq -0x10(%rbp), %rdi
callq 0xbba0
movb $0x1, -0x1(%rbp)
jmp 0xb68b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0xbb00
movq -0x10(%rbp), %rax
movq %rax, -0x4e8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20e20
movq -0x4e8(%rbp), %rdi
movl %eax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x20db0
movq $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xb687
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb890
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0xb614
movb $0x0, -0x1(%rbp)
jmp 0xb68b
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x2dc(%rbp), %rdi
xorl %edx, %edx
callq 0x18e70
leaq -0x4e0(%rbp), %rdi
leaq -0x2dc(%rbp), %rsi
callq 0x195c0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x4e0(%rbp), %rdx
callq 0xb020
movq -0x18(%rbp), %rax
movq %rax, -0x4f0(%rbp)
leaq -0x4e0(%rbp), %rdi
callq 0x7470
movq -0x4f0(%rbp), %rdi
movl %eax, %esi
callq 0xbaa0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xb5e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/DagGenerator.cpp
// Function: t2::GetNodeFlag(t2::JsonObjectValue const*, char const*, unsigned int)
static uint32_t GetNodeFlag(const JsonObjectValue* node, const char* name, uint32_t value)
{
  uint32_t result = 0;

  if (const JsonValue* val = node->Find(name))
  {
    if (const JsonBooleanValue* flag = val->AsBoolean())
    {
      if (flag->m_Boolean)
        result = value;
    }
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb9d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb6fa
movq -0x20(%rbp), %rdi
callq 0xbca0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb6f8
movq -0x28(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0xb6f6
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xb6f8
jmp 0xb6fa
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/HashTable.hpp
// Function: t2::CommonStringRecord* t2::HashTableLookup<t2::CommonStringRecord, 0u>(t2::HashTable<t2::CommonStringRecord, 0u>*, unsigned int, char const*)
T* HashTableLookup(HashTable<T, kFlags>* self, uint32_t hash, const char* string)
  {
    int index = HashTableBaseLookup(self, hash, string);

    if (-1 == index)
      return nullptr;

    return self->m_Payloads + index;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0xc0b0
movl %eax, -0x24(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x24(%rbp), %eax
jne 0xb77a
movq $0x0, -0x8(%rbp)
jmp 0xb791
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Buffer.hpp
// Function: void t2::BufferDestroy<char>(t2::Buffer<char>*, t2::MemAllocHeap*)
void BufferDestroy(Buffer<T>* buffer, MemAllocHeap* heap)
  {
    if (T* ptr = buffer->m_Storage)
    {
      HeapFree(heap, ptr);

      buffer->m_Storage  = nullptr;
      buffer->m_Size     = 0;
      buffer->m_Capacity = 0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb9c2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18960
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/JsonParse.hpp
// Function: t2::JsonValue::Find(char const*) const
inline const JsonValue* JsonValue::Find(const char* key) const
{
  const JsonObjectValue* obj = AsObject();
  for (size_t i = 0, count = obj->m_Count; i < count; ++i)
  {
    if (0 == strcmp(obj->m_Names[i], key))
      return obj->m_Values[i];
  }

  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb850
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xba52
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3658
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xba42
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xba5a
jmp 0xba44
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xba01
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/HashTable.hpp
// Function: void t2::HashTableBaseInit<0u>(t2::HashTableBase<0u>*, t2::MemAllocHeap*)
void HashTableBaseInit(HashTableBase<kFlags>* self, MemAllocHeap* heap)
  {
    self->m_Hashes         = nullptr;
    self->m_Strings        = nullptr;
    self->m_TableSize      = 0;
    self->m_TableSizeShift = 0;
    self->m_RecordCount    = 0;
    self->m_Heap           = heap;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Buffer.hpp
// Function: int* t2::BufferAlloc<int>(t2::Buffer<int>*, t2::MemAllocHeap*, unsigned long)
T* BufferAlloc(Buffer<T>* buffer, MemAllocHeap* heap, size_t count)
  {
    T            *storage  = buffer->m_Storage;
    const size_t  old_size = buffer->m_Size;
    const size_t  capacity = buffer->m_Capacity;

    if (old_size + count > capacity)
    {
      size_t new_capacity = capacity ? capacity *2 : 8;

      if (new_capacity < old_size + count)
        new_capacity = old_size + count;

      storage           = (T*) HeapReallocate(heap, storage, sizeof(T) *new_capacity);
      buffer->m_Storage  = storage;
      buffer->m_Capacity = new_capacity;
    }

    buffer->m_Size = old_size + count;
    return storage + old_size;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0xbed9
cmpq $0x0, -0x30(%rbp)
je 0xbe79
movq -0x30(%rbp), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0xbe84
movl $0x8, %eax
movq %rax, -0x40(%rbp)
jmp 0xbe84
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0xbea9
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
shlq $0x2, %rdx
callq 0x18980
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/HashTable.hpp
// Function: int t2::HashTableBaseLookup<0u>(t2::HashTableBase<0u>*, unsigned int, char const*)
int HashTableBaseLookup(HashTableBase<kFlags>* self, uint32_t hash, const char* string)
  {
    uint32_t size = self->m_TableSize;

    if (0 == size)
    {
      return -1;
    }

    int (*compare_fn)(const char* l, const char* r);

    if (kFlags & kFlagCaseInsensitive)
    {
      compare_fn = FastCompareNoCase;
    }
    else
    {
      compare_fn = strcmp;
    }

    const uint32_t* hashes = self->m_Hashes;
    const char* const* strings = self->m_Strings;

    uint32_t index = hash & (size - 1);

    for (;;)
    {
      uint32_t candidate_hash = hashes[index];

      if (!candidate_hash)
        return -1;

      if (hash == candidate_hash)
      {
        const char* candidate_string = strings[index];
        if (candidate_string == string || compare_fn(candidate_string, string) == 0)
        {
          return index;
        }
      }

      index = (index + 1) & (size - 1);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jne 0xc0e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc17d
movq 0x22ef1(%rip), %rax     # 0x2efd8
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0xc12c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc17d
movl -0x14(%rbp), %eax
cmpl -0x48(%rbp), %eax
jne 0xc16a
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xc160
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0xc168
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc17d
jmp 0xc16a
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x44(%rbp)
jmp 0xc110
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/HashTable.hpp
// Function: int t2::HashTableBaseInsert<t2::HashTable<t2::CommonStringRecord, 0u>>(t2::HashTable<t2::CommonStringRecord, 0u>*, unsigned int, char const*)
int HashTableBaseInsert(TableType* self, uint32_t hash, const char* string)
  {
    uint32_t record_count = self->m_RecordCount;
    uint32_t table_size = self->m_TableSize;
    uint64_t load = 0x100 * uint64_t(record_count + 1) >> uint64_t(self->m_TableSizeShift);

    if (load > 0x050)
    {
      HashTableGrow(self);
      table_size = self->m_TableSize;
    }

    uint32_t index = hash & (table_size - 1);

    uint32_t* hashes = self->m_Hashes;

    while (hashes[index] != 0)
    {
      index = (index + 1) & (table_size - 1);
    }

    hashes[index] = hash;
    self->m_Strings[index] = string;
    self->m_RecordCount = record_count + 1;

    return index;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x8, %rax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
cmpq $0x50, -0x28(%rbp)
jbe 0xc1eb
movq -0x8(%rbp), %rdi
callq 0xc260
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0xc224
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc204
movl -0xc(%rbp), %edx
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Driver.cpp
// Function: t2::DriverOptionsInit(t2::DriverOptions*)
void DriverOptionsInit(DriverOptions* self)
{
  self->m_ShowHelp        = false;
  self->m_DryRun          = false;
  self->m_ForceDagRegen   = false;
  self->m_ShowTargets     = false;
  self->m_DebugMessages   = false;
  self->m_Verbose         = false;
  self->m_SpammyVerbose   = false;
  self->m_DisplayStats    = false;
  self->m_GenDagOnly      = false;
  self->m_Quiet           = false;
  self->m_IdeGen          = false;
  self->m_Clean           = false;
  self->m_Rebuild         = false;
  self->m_DebugSigning    = false;
  self->m_ContinueOnError = false;
  self->m_QuickstartGen   = false;
  self->m_ThreadCount     = GetCpuCount();
  self->m_WorkingDir      = nullptr;
  self->m_DAGFileName     = ".tundra2.dag";
  self->m_ProfileOutput   = nullptr;
#if defined(TUNDRA_WIN32)
  self->m_RunUnprotected  = false;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x6(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x7(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x9(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xb(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xd(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xe(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xf(%rax)
callq 0x7e10
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0x17087(%rip), %rcx     # 0x245a7
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Driver.cpp
// Function: t2::DriverInitData(t2::Driver*)
bool DriverInitData(Driver* self)
{
  ProfilerScope prof_scope("Tundra InitData", 0);

  DigestCacheInit(&self->m_DigestCache, MB(128));

  if (!DriverPrepareDag(self, s_DagFileName))
    return false;

  DigestCacheOpen(&self->m_DigestCache, self->m_DagData->m_DigestCacheFileName);

  LoadFrozenData<StateData>(self->m_DagData->m_StateFileName, &self->m_StateFile, &self->m_StateData);

  LoadFrozenData<ScanData>(self->m_DagData->m_ScanCacheFileName, &self->m_ScanFile, &self->m_ScanData);

  ScanCacheSetCache(&self->m_ScanCache, self->m_ScanData);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x16e4a(%rip), %rsi     # 0x2463d
leaq -0x14(%rbp), %rdi
xorl %edx, %edx
callq 0x67e0
movq -0x10(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x1f340
jmp 0xd815
movq -0x10(%rbp), %rdi
movq 0x21e38(%rip), %rsi     # 0x2f658
callq 0xd950
movb %al, -0x29(%rbp)
jmp 0xd82a
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xd85d
jmp 0xd833
movb $0x0, -0x1(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0xd929
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x6980
jmp 0xd93d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x268, %rcx            # imm = 0x268
movq %rcx, -0x40(%rbp)
movq 0xa0(%rax), %rdi
addq $0x7c, %rdi
callq 0x6e20
movq %rax, -0x38(%rbp)
jmp 0xd885
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x1f3e0
jmp 0xd894
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
addq $0x6c, %rdi
callq 0x6e20
movq %rax, -0x48(%rbp)
jmp 0xd8ae
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
addq $0x60, %rsi
addq $0xa8, %rdx
callq 0xda30
jmp 0xd8cb
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
addq $0x74, %rdi
callq 0x6e20
movq %rax, -0x50(%rbp)
jmp 0xd8e5
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
subq $-0x80, %rsi
addq $0xb0, %rdx
callq 0xdb60
jmp 0xd902
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0xb0(%rax), %rsi
callq 0x1a0a0
jmp 0xd91e
movb $0x1, -0x1(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x6980
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x35c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Driver.cpp
// Function: t2::DriverPrepareDag(t2::Driver*, char const*)
static bool DriverPrepareDag(Driver* self, const char* dag_fn)
{
  // Try to use an existing DAG
  if (!self->m_Options.m_ForceDagRegen && LoadFrozenData<DagData>(dag_fn, &self->m_DagFile, &self->m_DagData))
  {
    if (DriverCheckDagSignatures(self))
    {
      Log(kDebug, "DAG signatures match - using existing data w/o Lua invocation");
      return true;
    }

    MmapFileUnmap(&self->m_DagFile);
  }

  // We need to generate the DAG data
  if (!GenerateDag(s_BuildFile, dag_fn))
    return false;

  // The DAG had better map in now, or we can give up.
  if (!LoadFrozenData<DagData>(dag_fn, &self->m_DagFile, &self->m_DagData))
  {
    Log(kError, "panic: couldn't load in freshly generated DAG");
    return false;
  }

  // In checked builds, make sure signatures are valid.
  CHECK(DriverCheckDagSignatures(self));

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0xba(%rax)
jne 0xd9c4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
movq -0x10(%rbp), %rdx
addq $0xa0, %rdx
callq 0x101b0
testb $0x1, %al
jne 0xd98f
jmp 0xd9c4
movq -0x10(%rbp), %rdi
callq 0x102f0
testb $0x1, %al
jne 0xd99e
jmp 0xd9b7
movl $0x8, %edi
leaq 0x16e35(%rip), %rsi     # 0x247df
movb $0x0, %al
callq 0x7a60
movb $0x1, -0x1(%rbp)
jmp 0xda1f
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x18c60
movq 0x21c85(%rip), %rdi     # 0x2f650
movq -0x18(%rbp), %rsi
callq 0x8550
testb $0x1, %al
jne 0xd9de
movb $0x0, -0x1(%rbp)
jmp 0xda1f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
movq -0x10(%rbp), %rdx
addq $0xa0, %rdx
callq 0x101b0
testb $0x1, %al
jne 0xda17
movl $0x1, %edi
leaq 0x16e13(%rip), %rsi     # 0x2481d
movb $0x0, %al
callq 0x7a60
movb $0x0, -0x1(%rbp)
jmp 0xda1f
jmp 0xda19
jmp 0xda1b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)