LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::DefaultPrintTo<int>(testing::internal::WrapPrinterType<(testing::internal::DefaultPrinterType)1>, int*, std::ostream*)
void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
                    T* p, ::std::ostream* os) {
  if (p == NULL) {
    *os << "NULL";
  } else {
    // T is not a function type.  We just call << to print p,
    // relying on ADL to pick up user-defined << for their pointer
    // types, if any.
    *os << p;
  }
}

// Assembly:
movq %rsi, %rcx
testq %rdi, %rdi
je 0x32e89
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xc470
leaq 0x2052c(%rip), %rsi     # 0x533bc
movl $0x4, %edx
movq %rcx, %rdi
jmp 0xc700
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/Test_Hash.cpp
// Function: HashTest_CompareLess_Test::TestBody()
TEST(HashTest, CompareLess)
{
#if ENABLED(USE_FAST_HASH)
  HashDigest a, b;
  a.m_Words64[0] = 0; a.m_Words64[1] = 0;
  b.m_Words64[0] = 1; b.m_Words64[1] = 0;

  EXPECT_TRUE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0;
  b.m_Words64[0] = 0; b.m_Words64[1] = 1;

  EXPECT_TRUE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0xffffffffffffffffull;
  b.m_Words64[0] = 1; b.m_Words64[1] = 0;

  EXPECT_TRUE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0xffffffffffffffffull;
  b.m_Words64[0] = 0; b.m_Words64[1] = 0xfffffffffffffffeull;

  EXPECT_FALSE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0xffffffffffffffffull;
  b.m_Words64[0] = 0; b.m_Words64[1] = 0xffffffffffffffffull;

  EXPECT_FALSE(a < b);
#endif
}

// Assembly:
subq $0x18, %rsp
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c37a
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c37a
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c37a
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c37a
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c37a
addq $0x18, %rsp
retq
jmp 0x33892
jmp 0x33892
jmp 0x33892
jmp 0x33892
movq %rax, %rdi
callq 0x287ef
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperOpFailure<std::nullptr_t, t2::IncludeData*>(char const*, char const*, std::nullptr_t const&, t2::IncludeData* const&, char const*)
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
                                   const T1& val1, const T2& val2,
                                   const char* op) {
  return AssertionFailure()
         << "Expected: (" << expr1 << ") " << op << " (" << expr2
         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
         << " vs " << FormatForComparisonFailureMessage(val2, val1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x125e8
leaq 0x1c4b8(%rip), %rsi     # 0x5220d
movq %r12, %rdi
callq 0x29878
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x1ebd1(%rip), %rsi     # 0x54942
movq %rax, %rdi
callq 0x28b1a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x1c48b(%rip), %rsi     # 0x52216
movq %rax, %rdi
callq 0x28b1a
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x1c479(%rip), %rsi     # 0x52220
movq %rax, %rdi
callq 0x29878
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x35eb5
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0x2893a
leaq 0x1c459(%rip), %rsi     # 0x5222c
movq %rax, %rdi
callq 0x29016
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x35c72
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x2893a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1319a
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35e1e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35e39
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x287ef
jmp 0x35e80
jmp 0x35ea0
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35e83
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x35e83
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35ea3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x35ea3
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/Test_TargetSelect.cpp
// Function: TargetSelectTest_TargetNames_Test::TestBody()
TEST_F(TargetSelectTest, TargetNames)
{
  const TargetSpec specs[] = { { 0, 0, 0 } };
  const char* names[] = { "foo-bar", "some_string" };
  const char* expected_names[] = { "foo-bar", "some_string" };
  EXPECT_TRUE(RunTest(names, ARRAY_SIZE(names), specs, ARRAY_SIZE(specs), expected_names, ARRAY_SIZE(expected_names)));
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdx
movq %rbx, (%rdx)
movl $0x0, 0x8(%rdx)
movaps 0x346ff(%rip), %xmm0    # 0x70540
leaq 0x60(%rsp), %rdi
movaps %xmm0, (%rdi)
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movl $0x1, %ecx
movl $0x2, %r9d
movl $0x2, %esi
callq 0x3cc7a
movb %al, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
testb %al, %al
jne 0x3bf1a
movq %rsp, %rdi
callq 0x12e46
leaq 0x19ab2(%rip), %rdx     # 0x55939
leaq 0x17412(%rip), %rcx     # 0x532a0
leaq 0x168c5(%rip), %r8      # 0x5275a
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x143f5
movq 0x20(%rsp), %r8
leaq 0x199ac(%rip), %rdx     # 0x5585c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x72, %ecx
callq 0x10b64
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x8(%rsp), %rdi
callq 0x10bd0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bef6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, (%rsp)
je 0x3bf1a
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x3bf1a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3bf1a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
addq $0x70, %rsp
popq %rbx
retq
jmp 0x3bf7f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10bd0
jmp 0x3bf40
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bf60
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x3bf60
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31a70
jmp 0x3bf6d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/Test_TargetSelect.cpp
// Function: TargetSelectTest_TheMotherLode_Test::TestBody()
TEST_F(TargetSelectTest, TheMotherLode)
{
  const TargetSpec specs[] = {
    { 1, 0, 0 },
    { 1, 0, 1 },
    { 1, 1, 0 },
    { 1, 1, 1 },
    { 2, 0, 0 },
    { 2, 0, 1 },
    { 2, 1, 0 },
    { 2, 1, 1 }
  };
  const char* names[] = { "random-junk", "linux-gcc", "macosx-clang", "default", "special", "debug", "production", "blah" };
  const char* expected_names[] = { "blah", "random-junk" };
  EXPECT_TRUE(RunTest(names, ARRAY_SIZE(names), specs, ARRAY_SIZE(specs), expected_names, ARRAY_SIZE(expected_names)));
}

// Assembly:
pushq %rbx
subq $0xf0, %rsp
leaq 0x19035(%rip), %rsi     # 0x55b20
leaq 0x90(%rsp), %rdx
movl $0xc, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x33adb(%rip), %xmm0    # 0x705e0
leaq 0x50(%rsp), %rdi
movaps %xmm0, 0x30(%rdi)
movaps 0x33abb(%rip), %xmm0    # 0x705d0
movaps %xmm0, 0x20(%rdi)
movaps 0x33aa0(%rip), %xmm0    # 0x705c0
movaps %xmm0, 0x10(%rdi)
movaps 0x33a85(%rip), %xmm0    # 0x705b0
movaps %xmm0, (%rdi)
movaps 0x33abb(%rip), %xmm0    # 0x705f0
leaq 0x40(%rsp), %r8
movaps %xmm0, (%r8)
movl $0x8, %ecx
movl $0x2, %r9d
movl $0x8, %esi
callq 0x3cc7a
movb %al, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
testb %al, %al
jne 0x3cc0a
movq %rsp, %rdi
callq 0x12e46
leaq 0x18dc2(%rip), %rdx     # 0x55939
leaq 0x16722(%rip), %rcx     # 0x532a0
leaq 0x15bd5(%rip), %r8      # 0x5275a
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x143f5
movq 0x20(%rsp), %r8
leaq 0x18cbc(%rip), %rdx     # 0x5585c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0xbb, %ecx
callq 0x10b64
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x8(%rsp), %rdi
callq 0x10bd0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cbe6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, (%rsp)
je 0x3cc0a
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x3cc0a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3cc0a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
addq $0xf0, %rsp
popq %rbx
retq
jmp 0x3cc72
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10bd0
jmp 0x3cc33
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cc53
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x3cc53
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31a70
jmp 0x3cc60
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x287ef
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/src/TargetSelect.hpp
// Function: void std::__move_median_to_first<t2::TargetSpec*, __gnu_cxx::__ops::_Iter_less_iter>(t2::TargetSpec*, t2::TargetSpec*, t2::TargetSpec*, t2::TargetSpec*, __gnu_cxx::__ops::_Iter_less_iter)
inline bool operator<(const TargetSpec& l, const TargetSpec& r)
{
  if (l.m_ConfigIndex < r.m_ConfigIndex)
    return true;
  if (l.m_ConfigIndex > r.m_ConfigIndex)
    return false;
  if (l.m_VariantIndex < r.m_VariantIndex)
    return true;
  if (l.m_VariantIndex > r.m_VariantIndex)
    return false;

  return l.m_SubVariantIndex < r.m_SubVariantIndex;
}

// Assembly:
movl (%rsi), %eax
movl (%rdx), %r8d
cmpl %r8d, %eax
jge 0x3d3b5
movl (%rcx), %r9d
cmpl %r9d, %r8d
jge 0x3d3e4
movl 0x8(%rdi), %eax
movl %eax, -0x8(%rsp)
movq (%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x8(%rdx), %eax
movl %eax, 0x8(%rdi)
movq (%rdx), %rax
movq %rax, (%rdi)
movl -0x8(%rsp), %eax
movl %eax, 0x8(%rdx)
movq -0x10(%rsp), %rax
movq %rax, (%rdx)
retq
jle 0x3d416
movl (%rcx), %r9d
cmpl %r9d, %eax
jl 0x3d474
jle 0x3d46c
cmpl %r9d, %r8d
jl 0x3d3eb
jg 0x3d38a
movl 0x4(%rcx), %eax
cmpl %eax, 0x4(%rdx)
jl 0x3d3eb
jg 0x3d38a
movl 0x8(%rdx), %eax
cmpl 0x8(%rcx), %eax
jge 0x3d38a
jmp 0x3d3eb
jle 0x3d436
cmpl %r9d, %eax
jge 0x3d456
movl 0x8(%rdi), %eax
movl %eax, -0x8(%rsp)
movq (%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rdi)
movq (%rcx), %rax
movq %rax, (%rdi)
movl -0x8(%rsp), %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rsp), %rax
movq %rax, (%rcx)
retq
movl 0x4(%rdx), %r9d
cmpl %r9d, 0x4(%rsi)
jl 0x3d382
jg 0x3d3b7
movl 0x8(%rsi), %r9d
cmpl 0x8(%rdx), %r9d
jl 0x3d382
jmp 0x3d3b7
movl 0x4(%rcx), %r8d
cmpl %r8d, 0x4(%rdx)
jl 0x3d38a
jg 0x3d3e6
movl 0x8(%rdx), %r8d
cmpl 0x8(%rcx), %r8d
jl 0x3d38a
jmp 0x3d3e6
jg 0x3d474
movl 0x4(%rcx), %eax
cmpl %eax, 0x4(%rsi)
jl 0x3d3eb
jg 0x3d474
movl 0x8(%rsi), %eax
cmpl 0x8(%rcx), %eax
jl 0x3d3eb
jmp 0x3d474
movl 0x4(%rcx), %eax
cmpl %eax, 0x4(%rsi)
jge 0x3d49f
movl 0x8(%rdi), %eax
movl %eax, -0x8(%rsp)
movq (%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
movl -0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq -0x10(%rsp), %rax
movq %rax, (%rsi)
retq
jg 0x3d3c9
movl 0x8(%rsi), %eax
cmpl 0x8(%rcx), %eax
jge 0x3d3c9
jmp 0x3d474
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/Test_HashTable.cpp
// Function: HashTableTest_Empty_Test::TestBody()
TEST_F(HashTableTest, Empty)
{
  HashTable<int, kFlagCaseSensitive> tbl;
  HashTableInit(&tbl, &heap);
  EXPECT_EQ(0, tbl.m_RecordCount);
  HashTableDestroy(&tbl);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %r8
movups %xmm0, -0xc(%r8)
movaps %xmm0, -0x18(%r8)
movq %rdi, 0x8(%r8)
movq $0x0, 0x10(%r8)
movq %rsp, %rcx
movl $0x0, (%rcx)
leaq 0x154e1(%rip), %rsi     # 0x53b38
leaq 0x17d2f(%rip), %rdx     # 0x5638d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3ba7c
cmpb $0x0, (%rbx)
jne 0x3e6e4
movq %rsp, %rdi
callq 0x12e46
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3e687
movq (%rax), %r8
jmp 0x3e68e
leaq 0x19839(%rip), %r8      # 0x57ec7
leaq 0x17cdc(%rip), %rdx     # 0x56371
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x34, %ecx
callq 0x10b64
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x8(%rsp), %rdi
callq 0x10bd0
cmpq $0x0, (%rsp)
je 0x3e6e4
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x3e6e4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3e6e4
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
leaq 0x20(%rsp), %rdi
callq 0x3fc31
addq $0x50, %rsp
popq %rbx
retq
jmp 0x3e733
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10bd0
jmp 0x3e714
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31a70
jmp 0x3e721
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/Test_HashTable.cpp
// Function: HashSetTest_Empty_Test::TestBody()
TEST_F(HashSetTest, Empty)
{
  HashSet<kFlagCaseSensitive> tbl;
  HashSetInit(&tbl, &heap);
  EXPECT_EQ(0, tbl.m_RecordCount);
  HashSetDestroy(&tbl);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %r8
movups %xmm0, -0xc(%r8)
movaps %xmm0, -0x18(%r8)
movq %rdi, 0x8(%r8)
movq %rsp, %rcx
movl $0x0, (%rcx)
leaq 0x148e1(%rip), %rsi     # 0x53b38
leaq 0x1712f(%rip), %rdx     # 0x5638d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3ba7c
cmpb $0x0, (%rbx)
jne 0x3f2e4
movq %rsp, %rdi
callq 0x12e46
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3f287
movq (%rax), %r8
jmp 0x3f28e
leaq 0x18c39(%rip), %r8      # 0x57ec7
leaq 0x170dc(%rip), %rdx     # 0x56371
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x78, %ecx
callq 0x10b64
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x8(%rsp), %rdi
callq 0x10bd0
cmpq $0x0, (%rsp)
je 0x3f2e4
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x3f2e4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3f2e4
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x41eea
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x41eea
addq $0x50, %rsp
popq %rbx
retq
jmp 0x3f347
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10bd0
jmp 0x3f328
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31a70
jmp 0x3f335
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/Test_HashTable.cpp
// Function: HashSetTest_Single_Test::TestBody()
TEST_F(HashSetTest, Single)
{
  HashSet<kFlagCaseSensitive> tbl;
  HashSetInit(&tbl, &heap);
  HashSetInsert(&tbl, 1, "foo");
  EXPECT_EQ(1, tbl.m_RecordCount);
  ASSERT_TRUE(HashSetLookup(&tbl, 1, "foo"));
  HashSetDestroy(&tbl);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movups %xmm0, 0xc(%rax)
movaps %xmm0, (%rax)
movq %rdi, 0x20(%rax)
leaq 0x16e34(%rip), %rdx     # 0x561a7
movq %rax, %rdi
movl $0x1, %esi
callq 0x406fe
leaq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0x58(%rsp), %r8
leaq 0x13de0(%rip), %rsi     # 0x53177
leaq 0x16fef(%rip), %rdx     # 0x5638d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3ba7c
cmpb $0x0, (%rbx)
jne 0x3f424
leaq 0x8(%rsp), %rdi
callq 0x12e46
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x3f3c9
movq (%rax), %r8
jmp 0x3f3d0
leaq 0x18af7(%rip), %r8      # 0x57ec7
leaq 0x16f9a(%rip), %rdx     # 0x56371
movq %rsp, %rdi
movl $0x1, %esi
movl $0x81, %ecx
callq 0x10b64
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x10c00
movq %rsp, %rdi
callq 0x10bd0
cmpq $0x0, 0x8(%rsp)
je 0x3f424
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x3f424
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3f424
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
leaq 0x16d70(%rip), %rdx     # 0x561a7
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x40288
leaq 0x10(%rsp), %rbx
cmpl $-0x1, %eax
setne -0x8(%rbx)
movq $0x0, (%rbx)
je 0x3f488
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c37a
movq 0x40(%rsp), %rsi
movq 0x60(%rsp), %rdi
callq 0x41eea
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %rdi
callq 0x41eea
jmp 0x3f534
movq %rsp, %rdi
callq 0x12e46
leaq 0x16f53(%rip), %rdx     # 0x563ea
leaq 0x13e02(%rip), %rcx     # 0x532a0
leaq 0x132b5(%rip), %r8      # 0x5275a
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x143f5
movq 0x20(%rsp), %r8
leaq 0x16eb1(%rip), %rdx     # 0x56371
leaq 0x18(%rsp), %rdi
movl $0x2, %esi
movl $0x82, %ecx
callq 0x10b64
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x18(%rsp), %rdi
callq 0x10bd0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f506
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, (%rsp)
je 0x3f52a
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x3f52a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3f52a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c37a
addq $0x70, %rsp
popq %rbx
retq
jmp 0x3f5b9
jmp 0x3f5b9
jmp 0x3f5b9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x10bd0
jmp 0x3f552
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f572
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x3f572
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31a70
jmp 0x3f57f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x3f5aa
movq %rax, %rbx
movq %rsp, %rdi
callq 0x10bd0
jmp 0x3f596
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31a70
jmp 0x3f5a5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
jmp 0x3f5b9
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/theindiependencegame.c
// Function: clock
void *_clock(void * cq){
  time_t clk,ini,clkDanger,iniDanger;
  double remaining,remainingDanger;
	sc_rectangle *sc_clk;
	sc_clk = win_new(0,SCREENX+2,CLKY,CLKX,BGCOLOR,CHARCOLOR);
  ini = time(&ini);
  while(inDanger==0 && end==0) {
    noDanger: clk=time(&clk);
    remaining= TIME - difftime(clk,ini);
		interface_printClock(sc_clk,remaining,inDanger);
    usleep(1000000);
  }
	if(inDanger==1){
		iniDanger = time(&iniDanger);
	}
	while(inDanger==1 && end==0){
		clkDanger = time(&clkDanger);
		remainingDanger = DANGERTIME - difftime(clkDanger,iniDanger);
		interface_printClock(sc_clk,remainingDanger,inDanger);
		usleep(1000000);
	}
	if(end!=0) return NULL;
	goto noDanger;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %edi, %edi
movl $0x52, %esi
movl $0x5, %edx
movl $0x28, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x3ec7
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x1110
movq %rax, (%r14)
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movzwl 0x8da1(%rip), %ecx      # 0xa138
movzwl 0x8d9c(%rip), %eax      # 0xa13a
movl %ecx, %edx
orw %ax, %dx
je 0x1447
cmpw $0x1, %cx
jne 0x1442
movq %r15, %rdi
callq 0x1110
cmpw $0x1, 0x8d75(%rip)      # 0xa138
sete %cl
cmpw $0x0, 0x8d6c(%rip)      # 0xa13a
movq %rax, 0x8(%rsp)
sete %al
andb %al, %cl
cmpb $0x1, %cl
jne 0x143c
movq %r12, %rdi
callq 0x1110
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x10b0
movsd 0x4c09(%rip), %xmm1     # 0x6008
subsd %xmm0, %xmm1
movswl 0x8d2e(%rip), %esi      # 0xa138
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x57d1
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x11c0
movzwl 0x8d13(%rip), %ecx      # 0xa13a
testw %cx, %cx
sete %al
cmpw $0x1, 0x8d03(%rip)      # 0xa138
jne 0x143c
testw %cx, %cx
je 0x13dd
testb %al, %al
jne 0x1447
jmp 0x148f
testw %ax, %ax
jne 0x148f
movq %r14, %rdi
callq 0x1110
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x10b0
movsd 0x4ba7(%rip), %xmm1     # 0x6010
subsd %xmm0, %xmm1
movswl 0x8cc4(%rip), %esi      # 0xa138
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x57d1
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x11c0
jmp 0x1390
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/theindiependencegame.c
// Function: main
int main(int argc, char **argv) {
  pthread_t key;
  pthread_t clk;

  _term_init();

	_intro();
	end = 0;
	pthread_create(&clk,NULL,_clock,NULL);

	_play((void *) key);


}

// Assembly:
pushq %rax
callq 0x12cc
callq 0x149d
movw $0x0, 0x822e(%rip)      # 0xa13a
leaq -0xbcf(%rip), %rdx      # 0x1344
movq %rsp, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1160
callq 0x1d3a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: dialogs_destroy
void dialogs_destroy(Dialogs *d){
    int i=0,j=0;
    if(d){
        while(i<MAX_NPC){
            j = 0;
            while(j<MAX_DLG){
                if(d->dlgs[i][j]) free(d->dlgs[i][j]);
                else if(j == 0) goto freetag;
                else break;
                j++;
            }
            i++;
        }
    }
    freetag:free(d);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1f74
xorl %r14d, %r14d
movq %rbx, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x1f60
callq 0x1030
incq %r12
cmpq $0xf, %r12
jne 0x1f41
cmpq $0x1c, %r14
jbe 0x1f6b
jmp 0x1f74
testq %r12, %r12
je 0x1f74
cmpq $0x1d, %r14
jae 0x1f74
incq %r14
addq $0x78, %r15
jmp 0x1f3e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: dialogs_load
Dialogs* dialogs_load(char* filename){
	Dialogs *d;
	int npc=0,dlg=0;
	char buff[1024];
	FILE *in;

	if(!filename) return NULL;

	d=(Dialogs*)malloc(sizeof(Dialogs));
	if(!d) return NULL;

	in = (FILE*) fopen(filename, "r");
	if(!in){
		free(d);
		return NULL;
	}

	while(!feof(in)){
		fscanf(in,"%d\t%d\t%[^\n]",&npc,&dlg,buff);
		d->dlgs[npc][dlg]=(char*)malloc(strlen(buff)+1);
        strcpy(d->dlgs[npc][dlg],buff);
	}

	fclose(in);
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
xorl %ebx, %ebx
movl %ebx, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
testq %rdi, %rdi
je 0x2068
movq %rdi, %r14
movl $0xe10, %edi            # imm = 0xE10
callq 0x1130
testq %rax, %rax
je 0x2066
movq %rax, %rbx
leaq 0x406f(%rip), %rsi      # 0x603a
movq %r14, %rdi
callq 0x1190
testq %rax, %rax
je 0x205e
movq %rax, %r14
movq %rax, %rdi
callq 0x10f0
testl %eax, %eax
jne 0x2054
leaq 0x417f(%rip), %r15      # 0x6171
leaq 0xc(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x1060
movq %rbp, %rdi
callq 0x1080
leaq 0x1(%rax), %rdi
callq 0x1130
movslq 0xc(%rsp), %rcx
movslq 0x8(%rsp), %rdx
imulq $0x78, %rcx, %rcx
addq %rbx, %rcx
movq %rax, (%rcx,%rdx,8)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1050
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x2001
movq %r14, %rdi
callq 0x1070
jmp 0x2068
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: inventory_destroy
void inventory_destroy(Inventory *inv){
	int i=0;
	if(inv){
	    if(inv->inv){
	        for(i=0;inv->inv[i];i++){
	            object_destroy(inv->inv[i]);
	        }
	        free(inv->inv);
	    }
	free(inv);
	}
	return;
}

// Assembly:
testq %rdi, %rdi
je 0x20cb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x20bc
movq (%rdi), %rax
testq %rax, %rax
je 0x20b7
movl $0x8, %r14d
movq %rax, %rdi
callq 0x3847
movq (%rbx), %rdi
movq (%rdi,%r14), %rax
addq $0x8, %r14
testq %rax, %rax
jne 0x209f
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: inventory_erase
int inventory_erase(Inventory *in, int oId){
	int i;
	if(!in || oId<0)return -1;
	for(i=oId; i<in->max && in->inv[i]!=NULL;i++){
	    if(in->inv[i]) object_destroy(in->inv[i]);
		if(in->inv[i+1] && i+1!=in->max){
			in->inv[i] = object_copy(in->inv[i+1]);
		}
		else{
			break;
		}
	}
	in->max--;
	return 0;
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sets %cl
orb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x236f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl %esi, %eax
jle 0x2361
movl %esi, %r14d
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x2361
incq %r14
callq 0x3847
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
movl 0x8(%rbx), %eax
testq %rdi, %rdi
je 0x2361
cmpq %rax, %r14
je 0x2361
callq 0x3a5c
movq (%rbx), %rcx
movq %rax, -0x8(%rcx,%r14,8)
movl 0x8(%rbx), %eax
cmpl %r14d, %eax
jle 0x2361
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
incq %r14
testq %rdi, %rdi
jne 0x2324
decl %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: inventory_insert
Inventory* inventory_insert(Inventory* inv, Object *o){
	if(!inv || !o)return NULL;

	inv->inv[inv->max]=object_copy(o);
	inv->max++;
	return inv;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x23ca
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3a5c
movq (%rbx), %rcx
movslq 0x8(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
jmp 0x23cc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: mobjects_destroy
void mobjects_destroy(Mobjects *m){
    int i=0,j=0;
    if(m){
        if(m->objs){
            while(i<MAX_PLC){
                j = 0;
                while(j<MAX_OBJ){
                    if(m->objs[i][j]) object_destroy(m->objs[i][j]);
                    else if(j == 0) goto freetag;
                    else break;
                    j++;
                }
                i++;
            }
        }
    }
    freetag:free(m);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2431
xorl %r14d, %r14d
movq %rbx, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x241d
callq 0x3847
incq %r12
cmpq $0xa, %r12
jne 0x23fe
cmpq $0x18, %r14
jbe 0x2428
jmp 0x2431
testq %r12, %r12
je 0x2431
cmpq $0x19, %r14
jae 0x2431
incq %r14
addq $0x50, %r15
jmp 0x23fb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: mobjects_insert
int mobjects_insert(Mobjects *m, Object *o){
	int i,roomid;
	if(!m || !o)return -1;
	roomid=object_getRoomId(o);
	for(i=0; m->objs[roomid][i]!=NULL && i<MAX_OBJ;i++);
	if(i<MAX_OBJ){
	    m->objs[roomid][i]=object_copy(o);
	    return 1;
	}
	else return 0;
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x26e1
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x39a8
movswq %ax, %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rbx
xorl %r15d, %r15d
movq %r15, %rcx
incq %r15
cmpq $0x9, %rcx
ja 0x26c2
cmpq $0x0, (%rbx,%rcx,8)
jne 0x26af
xorl %eax, %eax
cmpq $0x9, %rcx
ja 0x26dc
movq %r14, %rdi
callq 0x3a5c
movq %rax, -0x8(%rbx,%r15,8)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: mobjects_search
int mobjects_search(Mobjects *m, int roomid, int opx, int opy){
	int mid,mpx,mpy;
	int i=0;
	if(roomid < 0 || roomid > MAX_PLC || opx < 0 || opx > XLIMIT || opy < 0 || opy > YLIMIT || !m) return -1;
	while(i<MAX_OBJ || m->objs[roomid][i]){
		mid=object_getRoomId(m->objs[roomid][i]);
		mpx=object_getPx(m->objs[roomid][i]);
		mpy=object_getPy(m->objs[roomid][i]);
		if((roomid==mid && opx==mpx+1 && opy==mpy)||(roomid==mid && opx==mpx-1 && opy==mpy)||(roomid==mid && opx==mpx && opy==mpy+1)||(roomid==mid && opx==mpx && opy==mpy-1)){
			return i;
		}
		i++;
	}
		return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x27dc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
cmpl $0x1a, %esi
ja 0x27ce
movl %edx, %ebx
cmpl $0x50, %edx
ja 0x27ce
movl %ecx, %r14d
cmpl $0x24, %ecx
ja 0x27ce
movl %r15d, %eax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r12
movq (%rdi,%rax), %rdi
xorl %r13d, %r13d
movq %r12, (%rsp)
callq 0x39a8
movswl %ax, %ebp
movq (%r12,%r13,8), %rdi
callq 0x39b7
movq %r12, %rcx
movl %eax, %r12d
movq (%rcx,%r13,8), %rdi
callq 0x39c6
cmpl %r15d, %ebp
jne 0x276b
leal 0x1(%r12), %esi
cmpl %ebx, %esi
jne 0x276b
cmpl %r14d, %eax
je 0x27cb
cmpl %r15d, %ebp
jne 0x277e
leal -0x1(%r12), %esi
cmpl %ebx, %esi
jne 0x277e
cmpl %r14d, %eax
je 0x27cb
xorl %r15d, %ebp
xorl %ebx, %r12d
orl %ebp, %r12d
sete %sil
jne 0x2795
leal 0x1(%rax), %edi
cmpl %r14d, %edi
je 0x27cb
decl %eax
cmpl %r14d, %eax
sete %al
testb %al, %sil
jne 0x27cb
leaq 0x1(%r13), %rax
movq (%rsp), %r12
movq 0x8(%r12,%r13,8), %rdi
cmpq $0x9, %r13
movq %rax, %r13
jb 0x2738
movq %rax, %r13
testq %rdi, %rdi
jne 0x2738
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x27ce
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: mobjects_erase
Mobjects* mobjects_erase(Mobjects *m, int roomid, int id){
	int i=0;

	if(roomid < 0 || roomid > MAX_PLC || !m) return NULL;
	for(i=id; m->objs[roomid][i];i++){
			if(m->objs[roomid][i]) object_destroy(m->objs[roomid][i]);
		if(m->objs[roomid][i+1]){
			m->objs[roomid][i] = object_copy(m->objs[roomid][i+1]);
		}
		else{
			break;
		}
	}
	m->objs[roomid][i]=NULL;
	return m;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1b, %esi
setae %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x2858
movq %rdi, %rbx
movl %esi, %eax
movslq %edx, %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rdi, %rax
leaq (%rax,%rcx,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x285c
callq 0x3847
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x285c
callq 0x3a5c
movq %rax, (%r14)
movq 0x8(%r14), %rdi
addq $0x8, %r14
jmp 0x2833
xorl %ebx, %ebx
jmp 0x2863
movq $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: map_destroy
void map_destroy(Map *m){
	int i=0;
	if(m){
	    if(m->map){
	        for(i=0;m->map[i];i++){
	            place_destroy(m->map[i]);
	        }
	        free(m->map);
	    }
	free(m);
	}
	return;
}

// Assembly:
testq %rdi, %rdi
je 0x28bc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x28ad
movq (%rdi), %rax
testq %rax, %rax
je 0x28a8
movl $0x8, %r14d
movq %rax, %rdi
callq 0x3ae0
movq (%rbx), %rdi
movq (%rdi,%r14), %rax
addq $0x8, %r14
testq %rax, %rax
jne 0x2890
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: meeting_destroy
void meeting_destroy(Meeting *d){
    int i=0,j=0;
    if(d){
        while(i<MAX_MET){
            j = 0;
            while(j<MAX_Q){
                if(d->meet[i][j]) free(d->meet[i][j]);
                else if(j == 0) goto freetag;
                else break;
                j++;
            }
            i++;
        }
    }
    freetag:free(d);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2b3d
xorl %r14d, %r14d
movq %rbx, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x2b29
callq 0x1030
incq %r12
cmpq $0x3, %r12
jne 0x2b0a
cmpq $0x3, %r14
jbe 0x2b34
jmp 0x2b3d
testq %r12, %r12
je 0x2b3d
cmpq $0x4, %r14
jae 0x2b3d
incq %r14
addq $0x18, %r15
jmp 0x2b07
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: meeting_load
Meeting* meeting_load(char* filename){
	Meeting *d;
	int meet=0,q=0;
	short solution=0;
	char buff[512];
	FILE *in;

	if(!filename) return NULL;

	d=(Meeting*)malloc(sizeof(Meeting));
	if(!d) return NULL;

	in = (FILE*) fopen(filename, "r");
	if(!in){
		free(d);
		return NULL;
	}

	while(!feof(in)){
		fscanf(in,"%hd\t%d\t%d\t%[^\n]",&solution,&meet,&q,buff);
		d->meet[meet][q]=(char*)malloc(strlen(buff)+1);
    strcpy(d->meet[meet][q],buff);
		d->solution[meet][q]=solution;
	}

	fclose(in);
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
xorl %ebx, %ebx
movl %ebx, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
movw $0x0, 0x6(%rsp)
testq %rdi, %rdi
je 0x2c47
movq %rdi, %r14
movl $0x98, %edi
callq 0x1130
testq %rax, %rax
je 0x2c45
movq %rax, %rbx
leaq 0x349f(%rip), %rsi      # 0x603a
movq %r14, %rdi
callq 0x1190
testq %rax, %rax
je 0x2c3d
movq %rax, %r14
movq %rax, %rdi
callq 0x10f0
testl %eax, %eax
jne 0x2c33
leaq 0x78(%rbx), %r12
leaq 0x10(%rsp), %r15
movq %r14, %rdi
leaq 0x35af(%rip), %rsi      # 0x617d
leaq 0x6(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1060
movq %r15, %rdi
callq 0x1080
leaq 0x1(%rax), %rdi
callq 0x1130
movslq 0xc(%rsp), %rcx
movslq 0x8(%rsp), %r13
leaq (%rcx,%rcx,2), %rbp
leaq (%rbx,%rbp,8), %rcx
movq %rax, (%rcx,%r13,8)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1050
movzwl 0x6(%rsp), %eax
leaq (%r12,%rbp,2), %rcx
movw %ax, (%rcx,%r13,2)
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0x2bc4
movq %r14, %rdi
callq 0x1070
jmp 0x2c47
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_move
int bg_move(Player *c, int x, int y, Map *map,char*desc){
	int room;
	if(!c || !map)return -1;
	room = player_get_room(c);
	if(x<2) return bg_changeRoom(c,LEFT,room,map,desc);
	if (y>YLIMIT) return bg_changeRoom (c,DOWN,room,map,desc);
	if (x>XLIMIT) return bg_changeRoom (c,RIGHT,room,map,desc);
	if (y<0) return bg_changeRoom (c,UP,room,map,desc);
	if(place_blankSpace(map->map[room], x, y)==1){
			c=player_move(c, x, y);
			return B_MOVE;
	}
	return B_NOTHING;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movl %edx, %ebp
testq %rdi, %rdi
sete %cl
testq %r12, %r12
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x2cf0
movq %r8, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x3dee
cmpl $0x1, %r15d
jg 0x2c9c
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x2cfe
cmpl $0x25, %ebp
jl 0x2cab
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x2cfe
cmpl $0x51, %r15d
jb 0x2cbb
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x2cfe
testl %ebp, %ebp
js 0x2cf9
movq (%r12), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x3d71
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x2cf0
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3dd4
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movq %r12, %rcx
movq %r14, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d13
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_updateRoom
int bg_updateRoom(Mobjects *m, Map* map, Player *c){
    int roomid,px,py,i=0,id;
    short onoff,npc,meeting;

    if(!m || !map || !c) return -1;

    roomid=player_get_room(c);

    while(i<MAX_OBJ && m->objs[roomid][i]){
		onoff=object_getOnOff(m->objs[roomid][i]);
		px=object_getPx(m->objs[roomid][i]);
		py=object_getPy(m->objs[roomid][i]);
		if(onoff==1){
	    	npc=object_getNPC(m->objs[roomid][i]);
	    	meeting=object_getMeeting(m->objs[roomid][i]);
	    	id=object_getId(m->objs[roomid][i]);
	    	if(meeting==1){
	    	    place_drawchar(map->map[roomid],px,py,MEETING_CHAR);
	    	}
	    	else if (npc==1){
	    	    place_drawchar(map->map[roomid],px,py,NPC_CHAR);
	    	}
	    	else switch(id){
	    	    case(ID_BOX):{
	    	        if(object_getIsPick(m->objs[roomid][i])!=0)place_drawchar(map->map[roomid],px,py,BOX_CHAR);
	    	        break;
	    	    }
	    	    case(ID_PRINTER):{
	    	        place_drawchar(map->map[roomid],px,py,PRINTER_CHAR);
	    	        break;
	    	    }
	    	    case(ID_SHOP):{
	    	        place_drawchar(map->map[roomid],px,py,SHOP_CHAR);
	    	        break;
	    	    }
	    	    default: place_drawchar(map->map[roomid],px,py,DEFAULT_CHAR);
	    	}
		}
		i++;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
sete %al
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %sil
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %sil
jne 0x2fc8
movq %rdi, %r14
movq %rdx, %rdi
callq 0x3dee
cltq
movq %rax, 0x8(%rsp)
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %r14
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x2fc6
callq 0x3a02
movl %eax, %r13d
movq (%r14,%rbx,8), %rdi
callq 0x39b7
movl %eax, %ebp
movq (%r14,%rbx,8), %rdi
callq 0x39c6
cmpw $0x1, %r13w
jne 0x2fb9
movl %eax, %r12d
movq (%r14,%rbx,8), %rdi
callq 0x39d5
movl %eax, %r13d
movq (%r14,%rbx,8), %rdi
callq 0x39e4
movl %eax, %r15d
movq (%r14,%rbx,8), %rdi
callq 0x3999
movb $0x58, %cl
cmpw $0x1, %r15w
je 0x2f9b
movb $0x40, %cl
cmpw $0x1, %r13w
je 0x2f9b
cmpl $0x2, %eax
je 0x2f99
movb $0x2a, %cl
testl %eax, %eax
jne 0x2f9b
movq (%r14,%rbx,8), %rdi
callq 0x39f3
movb $0x4f, %cl
testw %ax, %ax
jne 0x2f9b
jmp 0x2fb9
movb $0x58, %cl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rdi
movzbl %cl, %ecx
movl %ebp, %esi
movl %r12d, %edx
callq 0x3d3d
incq %rbx
cmpq $0xa, %rbx
jne 0x2f16
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_checkDanger
short bg_checkDanger(Map* map, Player *c, Stat *s){
    int statStars, roomStars;
    if (!map || !c || !s) return -1;
    statStars = stat_get_stars(s);
    roomStars = place_getStars(map->map[player_get_room(c)]);
    if(statStars == -1 || roomStars == -1) return -1;
		if(statStars >= roomStars) return 1;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
movw $0xffff, %bx            # imm = 0xFFFF
orb %cl, %al
jne 0x3031
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x42d6
movl %eax, %ebp
movq (%r15), %r15
movq %r14, %rdi
callq 0x3dee
cltq
movq (%r15,%rax,8), %rdi
callq 0x3c61
cmpl $-0x1, %ebp
je 0x3031
cmpl $-0x1, %eax
je 0x3031
xorl %ebx, %ebx
cmpl %eax, %ebp
setge %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_box
int bg_box(Inventory* in,Player *c, Map *m, Stat*s,int oId) {
    if(!in || !c || !m) return -1;

    if(place_getLeaveBox(m->map[player_get_room(c)])==1 && place_getLeftBox(m->map[player_get_room(c)])==0 ){
        inventory_erase(in,oId);
        stat_add_motivation(s,BOX_MOTIVATION);
				place_setLeftBox(m->map[player_get_room(c)],1);
        return 1;
    }

    else if(place_getLeaveBox(m->map[player_get_room(c)])==1)return 2;
    else return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
orb %cl, %al
jne 0x32e3
movl %r8d, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdx), %r13
movq %rsi, %rdi
callq 0x3dee
cltq
movq (%r13,%rax,8), %rdi
callq 0x3c43
cmpw $0x1, %ax
jne 0x32bf
movq (%r14), %r13
movq %rbx, %rdi
callq 0x3dee
cltq
movq (%r13,%rax,8), %rdi
callq 0x3c52
testw %ax, %ax
je 0x32f5
movq (%r14), %r14
movq %rbx, %rdi
callq 0x3dee
cltq
movq (%r14,%rax,8), %rdi
callq 0x3c43
xorl %r13d, %r13d
cmpw $0x1, %ax
sete %r13b
addl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movl %ebp, %esi
callq 0x22f0
movq %r15, %rdi
movl $0xfa, %esi
callq 0x41e5
movq (%r14), %r14
movq %rbx, %rdi
callq 0x3dee
cltq
movq (%r14,%rax,8), %rdi
movl $0x1, %r13d
movl $0x1, %esi
callq 0x3b3a
jmp 0x32e3
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_use
int bg_use(Inventory* in, Stat *s, int oId, char* name, int*id){
	Object* o;
	int us,nchaos,ndanger,nmot,nmoney,objectId;
	if(!in || !s || oId<0 || oId>MAX_INV)return -1;
	if(oId >= in->max) return 0;
	o=inventory_get(in,oId);
	if(!o)return 0;
	if(object_getId(o)==ID_BOX){
		return B_BOX;
	}
	us=object_getUses(o);
	if(us==0)return 0;
	object_setUses(o, us-1);
	nchaos=object_getChaos(o);
	if(nchaos!=0){
		stat_add_chaos(s,nchaos);
	}
	ndanger=object_getDanger(o);
	if(ndanger!=0){
		stat_add_nodanger(s,ndanger);
	}
	nmot=object_getMotivation(o);
	if(nmot!=0){
		stat_add_motivation(s,nmot);
	}
	nmoney=object_getMoney(o);
	if(nmoney!=0){
		stat_add_money(s,nmoney);
	}
	us--;
	strcpy(name,object_getName(o));
	*id = object_getId(o);
	if(us==0){
		inventory_erase(in, oId);
	}
	return 1;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
cmpl $0xb, %edx
setae %al
orb %cl, %al
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jne 0x3456
movl %edx, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
cmpl %edx, 0x8(%rdi)
jle 0x3456
movq (%r14), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rbp
testq %rbp, %rbp
je 0x3456
movq %rsi, %r13
movq %r8, 0x10(%rsp)
movq %rbp, %rdi
callq 0x3999
testl %eax, %eax
je 0x3450
movq %rbp, %rdi
callq 0x3a11
testl %eax, %eax
je 0x3456
movq %rax, 0x8(%rsp)
leal -0x1(%rax), %esi
movq %rbp, %rdi
callq 0x3943
movq %rbp, %rdi
callq 0x3a3e
testl %eax, %eax
je 0x33d3
movq %r13, %rdi
movl %eax, %esi
callq 0x420a
movq %rbp, %rdi
callq 0x3a2f
testl %eax, %eax
je 0x33e9
movq %r13, %rdi
movl %eax, %esi
callq 0x427d
movq %rbp, %rdi
callq 0x3a20
testl %eax, %eax
je 0x33ff
movq %r13, %rdi
movl %eax, %esi
callq 0x41e5
movq %rbp, %rdi
callq 0x3a4d
testl %eax, %eax
je 0x3415
movq %r13, %rdi
movl %eax, %esi
callq 0x4262
movq %rbp, %rdi
callq 0x398d
movq %r12, %rdi
movq %rax, %rsi
callq 0x1050
movq %rbp, %rdi
callq 0x3999
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl $0x1, %r15d
cmpl $0x1, 0x8(%rsp)
jne 0x3456
movq %r14, %rdi
movl %ebx, %esi
callq 0x22f0
jmp 0x3456
movl $0x6, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_buy
short bg_buy(Inventory*shop, Inventory *in, Stat *s, int id, char* name){
	Object *o;
	int price;
	if(!shop || !in || !s || id<0 || id > MAX_INV) return -1;
	if(inventory_full(in)) return B_FULL;
	o=inventory_get(shop, id);
	if(!o)return -1;
	price = -object_getMoney(o);
	if(stat_get_money(s)<(-price)){
	    return 0;
	}
	stat_add_money(s,price);
	object_setMoney(o,0);
	strcpy(name,object_getName(o));
	if((inventory_insert(in, o))==NULL)return-1;
	inventory_erase(shop,id);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r13
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
cmpl $0xb, %ebx
setae %dl
orb %al, %dl
orb %cl, %dl
movw $0xffff, %ax            # imm = 0xFFFF
jne 0x353a
movq %rsi, %r15
movw $0xb, %ax
cmpl $0xa, 0x8(%rsi)
je 0x353a
movq %rdi, %r14
movq (%rdi), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rbp
movw $0xffff, %ax            # imm = 0xFFFF
testq %rbp, %rbp
je 0x353a
movq %r8, (%rsp)
movq %rbp, %rdi
callq 0x3a4d
movl %eax, %r12d
movq %r13, %rdi
callq 0x426e
cmpl %r12d, %eax
jge 0x34e6
xorl %eax, %eax
jmp 0x353a
negl %r12d
movq %r13, %rdi
movl %r12d, %esi
callq 0x4262
movq %rbp, %rdi
xorl %esi, %esi
callq 0x3981
movq %rbp, %rdi
callq 0x398d
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1050
movq %rbp, %rdi
callq 0x3a5c
movq (%r15), %rcx
movslq 0x8(%r15), %rdx
movq %rax, (%rcx,%rdx,8)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%r15)
movq %r14, %rdi
movl %ebx, %esi
callq 0x22f0
movw $0x1, %ax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rafa9811[P]theIndiependenceGame/background.c
// Function: bg_talk
int bg_talk(Dialogs *d, Player *c, Mobjects *m, char*dialog, char*name){
    Object *npc;
    int npcid, uses, oid, roomid, px, py;
	if(!m || !d )return -1;

	roomid=player_get_room(c);
	px=player_get_px(c);
	py=player_get_py(c);

    oid = mobjects_search(m,roomid,px,py);

    if(oid==-1) return 0;

	npc = mobjects_get(m,roomid,oid);

	if(object_getNPC(npc)!=1)return -1;
	strcpy(name,object_getName(npc));
  npcid = object_getId(npc);
  uses = object_getUses(npc);
	strcpy(dialog,d->dlgs[npcid][uses]);
	if(uses>0)object_setUses(npc,uses-1);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
testq %rdx, %rdx
sete %al
testq %rdi, %rdi
sete %dl
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
orb %al, %dl
jne 0x364c
movq %rsi, %rbx
movq %rdi, %r14
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsi, %rdi
callq 0x3dee
movl %eax, %r13d
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3dfd
movl %eax, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3e0b
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x26e2
cmpl $-0x1, %eax
je 0x364c
cmpl $0x1a, %r13d
ja 0x35dc
movl %r13d, %ecx
cltq
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
addq %rcx, %r12
movq (%r12,%rax,8), %r12
jmp 0x35df
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x39d5
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpw $0x1, %ax
jne 0x364c
movq %r12, %rdi
callq 0x398d
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1050
movq %r12, %rdi
callq 0x3999
movl %eax, %ebp
movq %r12, %rdi
callq 0x3a11
movl %eax, %ebx
movslq %ebp, %rax
movslq %ebx, %r15
imulq $0x78, %rax, %rax
addq %rax, %r14
movq (%r14,%r15,8), %rsi
movq 0x10(%rsp), %rdi
callq 0x1050
movl $0x1, %ebp
testl %r15d, %r15d
jle 0x364c
decl %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x3943
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq