LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: vec_from_poly(polynomial const&, int)
vector<vector<int>> vec_from_poly(const polynomial& poly, int n)
{
  vector<vector<int>> poly_vec = {};
  //assume poly is correctly ordered, else call poly.update() -> no more const
  //first extra, get size
  if (poly.size() == 0)
    {
      cout << "empty polynomial!" << endl;
      return {};
    }
  //  vector<int> vec(max_size,0);
  for (int i = 0; i < poly.Get_monomials().size(); ++i)
    {
      if (poly.Get_monomials()[i].Get_coeff() > 0)
	{
	  vector<int> term_i = table[poly.Get_monomials()[i].Get_term()].first;
	  poly_vec.emplace_back(term_i);
	}
    }
  return poly_vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x4, %rdx
testl %edx, %edx
je 0xdbb5
movq %rsi, %r14
movq %rbx, 0x18(%rsp)
pushq $0x8
popq %r13
xorl %ebp, %ebp
leaq 0xa624(%rip), %rbx      # 0x18170
leaq 0x20(%rsp), %r12
movq %rsp, %r15
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rbp, %rdx
jbe 0xdb9e
cmpl $0x0, (%rax,%r13)
jle 0xdb95
imulq $0x30, -0x8(%rax,%r13), %rsi
addq (%rbx), %rsi
movq %r12, %rdi
callq 0x3a1a
movq %r15, %rdi
movq %r12, %rsi
callq 0xe6aa
movq %r12, %rdi
callq 0x2dfe
movq (%r14), %rax
movq 0x8(%r14), %rcx
incq %rbp
addq $0x10, %r13
jmp 0xdb54
movaps (%rsp), %xmm0
movq 0x18(%rsp), %rbx
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0xdbd3
movq 0xa41c(%rip), %rdi      # 0x17fd8
leaq 0x18a5(%rip), %rsi      # 0xf468
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq %rbx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rsp, %rdi
callq 0x2c66
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdc0a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2dfe
jmp 0xdc0d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2c66
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: reduce(std::vector<polynomial, std::allocator<polynomial>>&)
int reduce(vector<polynomial>& G)
{
  int reductions = 0;
  int size = 0;
  int size_before = 1;
  while(size != size_before)
    {
      size_before = G.size();
      
      bool changed = true;
      while (changed)
	{
	  changed = false;
	  int size = G.size();
	  int i = 0;
	  while (i < G.size())
	    {
	      int j = 0;
	      while (j < G.size())
		{
		  if (j != i)
		    {
		      reduce(G[i],G[j],changed,reductions);//reduce G[i] by all other in G
		      int LT_G = G[i].Get_LT();
		      int LC_G = G[i].Get_LC();
		      if (LT_G == 0 && LC_G == 0) //is zero-polynomial
			{
			  G.erase (G.begin()+i);
			  size--;
			  j = G.size();
			  i = G.size();
			}
		    }
		  ++j;
		}
	      ++i;
	    }
	}
      //lc 1
      /* //works for p = 2
	 for (int i = 0; i < G.size(); ++i)
	 {
	 G[i] = G[i]*Inverse(G[i].Get_LC(),G[i].Get_p());
	 }
      */
      size = G.size();//maybe the size drops
    }
  return reductions;
  //sort(G);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
movq %rdi, %r14
xorl %ecx, %ecx
pushq $0x1
popq %rax
leaq 0xb(%rsp), %r15
cmpl %eax, %ecx
je 0xdd14
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rsi, %rax
shrq $0x5, %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, %al
je 0xdd03
movb $0x0, 0xb(%rsp)
xorl %r13d, %r13d
movslq %r13d, %rax
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rax, %rdx
jbe 0xdcfa
xorl %ebp, %ebp
movslq %ebp, %rax
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rax, %rdx
jbe 0xdcf2
cmpl %r13d, %ebp
je 0xdceb
movslq %r13d, %r12
shlq $0x5, %r12
leaq (%rsi,%r12), %rdi
shlq $0x5, %rax
addq %rsi, %rax
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xdd27
movq (%r14), %rsi
movq (%rsi,%r12), %rax
movl 0x8(%rax), %ecx
orl (%rax), %ecx
je 0xdccf
movq 0x8(%r14), %rcx
jmp 0xdcee
addq %r12, %rsi
movq %r14, %rdi
callq 0xe6e6
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rcx, %r13
subq %rsi, %r13
shrq $0x5, %r13
movl %r13d, %ebp
incl %ebp
jmp 0xdc84
incl %r13d
jmp 0xdc70
movb 0xb(%rsp), %al
jmp 0xdc60
subq %rsi, %rcx
shrq $0x5, %rcx
movq 0x10(%rsp), %rax
jmp 0xdc40
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: Tail(polynomial const&)
polynomial Tail(const polynomial& f) //returns all except leading monomial
{
  
  //cout << "Tail computation begin!" << endl;
  vector<monomial> tails = f.Get_monomials();
  //int n = tails[0].Get_term().size();
  if (tails.size() == 0)
    {
      cout << "Error in Tail! Empty polynomial!" << endl;
    }
  int p = tails[0].Get_p();
  //cout << "size of tails before removing: " << tails.size() << endl;
  tails.erase(tails.begin()); //remove LM
  //cout << "size of tails after removing: " << tails.size() << endl;
  if (tails.size() > 0)
    return polynomial(tails);
  else
    {// cout << "possible seg fault in Tail!" << endl;
      return polynomial({monomial(0, 0, p)});//construct zero polynomial
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x53f8
movq (%r14), %rdi
movq 0x8(%r14), %rdx
cmpq %rdi, %rdx
jne 0xdfab
movq 0xa04b(%rip), %rdi      # 0x17fd8
leaq 0x14e6(%rip), %rsi      # 0xf47a
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0xc(%rdi), %ebp
leaq 0x10(%rdi), %rsi
cmpq %rdx, %rsi
je 0xdfc9
subq %rsi, %rdx
callq 0x2230
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
addq $-0x10, %rdx
movq %rdx, 0x18(%rsp)
cmpq %rdi, %rdx
je 0xdfe6
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xd5a4
jmp 0xe01f
leaq 0x40(%rsp), %rsi
andq $0x0, (%rsi)
andl $0x0, 0x8(%rsi)
movl %ebp, 0xc(%rsi)
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x5ca8
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xd5a4
leaq 0x28(%rsp), %rdi
callq 0x2f74
leaq 0x10(%rsp), %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2f74
jmp 0xe04b
jmp 0xe048
jmp 0xe048
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: is_Smaller(polynomial const&, polynomial const&)
bool is_Smaller(const polynomial &one , const polynomial &two)
{
  if (one.Get_LT() < two.Get_LT())
    {
      return true;
    }
  if (two.Get_LT() < one.Get_LT())
    {
      return false;
    }
  //else
  return is_Smaller(Tail(one),Tail(two));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq (%rdi), %rax
movl (%rax), %eax
movq (%rsi), %rcx
movl (%rcx), %ecx
movb $0x1, %bl
cmpl %ecx, %eax
jl 0xe136
jle 0xe0f7
xorl %ebx, %ebx
jmp 0xe136
movq %rdi, %rsi
leaq 0x28(%rsp), %rdi
callq 0xdf62
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xdf62
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe0d7
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2f74
leaq 0x28(%rsp), %rdi
callq 0x2f74
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f74
jmp 0xe152
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/Finsenty54[P]fast_collision/my_first_try.cpp
// Function: main
int main()
{
    seed32_1=uint32(time(NULL));
    seed32_2=0x12345678;
    //MD5已经定义值
    uint32 IV[4] = { MD5IV[0], MD5IV[1], MD5IV[2], MD5IV[3] };
    //两个消息，每个有两个512bit块
	//16 * 32 = 512
	uint32 msg1block0[16]={0};
	uint32 msg1block1[16]={0};
	uint32 msg2block0[16]={0};
	uint32 msg2block1[16]={0};

	//计时器？？
	boost::timer::auto_cpu_timer runtime;
	find_collision(IV, msg1block0, msg1block1, msg2block0, msg2block1,true);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
xorl %edi, %edi
callq 0x10d0
leaq 0x9cca(%rip), %rcx      # 0xb0c8
movl %eax, (%rcx)
leaq 0x9cc5(%rip), %rax      # 0xb0cc
movl $0x12345678, (%rax)     # imm = 0x12345678
movaps 0x7bfc(%rip), %xmm0     # 0x9010
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
xorps %xmm0, %xmm0
leaq -0x190(%rbp), %r14
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq -0x150(%rbp), %r15
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq -0x110(%rbp), %r12
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq -0xd0(%rbp), %r13
movaps %xmm0, 0x30(%r13)
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
leaq -0x88(%rbp), %rdi
pushq $0x6
popq %rsi
callq 0x1050
pushq $0x1
popq %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x14e9
leaq -0x88(%rbp), %rdi
callq 0x1120
xorl %eax, %eax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x1120
movq %rbx, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O2/Finsenty54[P]fast_collision/./main.hpp
// Function: xrng64()
inline uint32 xrng64()
{
  //seed1 = time
	uint32 t = seed32_1 ^ (seed32_1 << 10);
	seed32_1 = seed32_2;
	seed32_2 = (seed32_2^(seed32_2>>10))^(t^(t>>13));
  //交互返回
	return seed32_1; //return seed32_2
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8743(%rip), %eax      # 0xb0c8
movl %eax, %ecx
shll $0xa, %ecx
xorl %eax, %ecx
movl 0x873a(%rip), %eax      # 0xb0cc
movl %eax, 0x8730(%rip)      # 0xb0c8
movl %eax, %edx
shrl $0xa, %edx
xorl %eax, %edx
xorl %ecx, %edx
shrl $0xd, %ecx
xorl %edx, %ecx
movl %ecx, 0x8720(%rip)      # 0xb0cc
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Finsenty54[P]fast_collision/block1.cpp
// Function: find_block1(unsigned int*, unsigned int const*)
void find_block1(uint32 block[], const uint32 IV[])
{
	if ( ((IV[1]^IV[2])&(1<<31))==0 && ((IV[1]^IV[3])&(1<<31))==0
		&& (IV[3]&(1<<25))==0 && (IV[2]&(1<<25))==0 && (IV[1]&(1<<25))==0 && ((IV[2]^IV[1])&1)==0 
	   )
	{
		uint32 IV2[4] = { IV[0]+(1<<31), IV[1]+(1<<31)+(1<<25), IV[2]+(1<<31)+(1<<25), IV[3]+(1<<31)+(1<<25) };
		if ((IV[1]&(1<<6))!=0 && (IV[1]&1)!=0) {
			std::cout << "S11" << std::flush;
			find_block1_stevens_11(block, IV2);
		} else if ((IV[1]&(1<<6))!=0 && (IV[1]&1)==0) {
			std::cout << "S10" << std::flush;
			find_block1_stevens_10(block, IV2);
		} else if ((IV[1]&(1<<6))==0 && (IV[1]&1)!=0) {
			std::cout << "S01" << std::flush;
			find_block1_stevens_01(block, IV2);
		} else {
			std::cout << "S00" << std::flush;
			find_block1_stevens_00(block, IV2);
		}
		block[4] += 1<<31;
		block[11] += 1<<15;
		block[14] += 1<<31;
	} else {
		std::cout << "W" << std::flush;
		find_block1_wang(block, IV);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %eax
movl 0x8(%rsi), %ecx
movl %ecx, %esi
xorl %eax, %esi
js 0x2b93
movl 0xc(%r14), %edx
movl %edx, %edi
xorl %eax, %edi
js 0x2b93
movl %ecx, %edi
orl %eax, %edi
orl %edx, %edi
andl $0x2000000, %edi        # imm = 0x2000000
andl $0x1, %esi
orl %edi, %esi
testl %esi, %esi
jne 0x2b93
movl $0x80000000, %esi       # imm = 0x80000000
xorl (%r14), %esi
movl %esi, -0x20(%rbp)
movl $0x82000000, %esi       # imm = 0x82000000
leal (%rax,%rsi), %edi
movl %edi, -0x1c(%rbp)
addl %esi, %ecx
movl %ecx, -0x18(%rbp)
addl %esi, %edx
movl %edx, -0x14(%rbp)
movq 0x8481(%rip), %rdi      # 0xafd8
andl $0x41, %eax
je 0x2be3
cmpl $0x1, %eax
je 0x2bc1
cmpl $0x40, %eax
jne 0x2c05
leaq 0x6578(%rip), %rsi      # 0x90ed
callq 0x10e0
movq %rax, %rdi
callq 0x10a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x534c
jmp 0x2c25
movq 0x843e(%rip), %rdi      # 0xafd8
leaq 0x6558(%rip), %rsi      # 0x90f9
callq 0x10e0
movq %rax, %rdi
callq 0x10a0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x735c
leaq 0x6529(%rip), %rsi      # 0x90f1
callq 0x10e0
movq %rax, %rdi
callq 0x10a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x438c
jmp 0x2c25
leaq 0x650b(%rip), %rsi      # 0x90f5
callq 0x10e0
movq %rax, %rdi
callq 0x10a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x3390
jmp 0x2c25
leaq 0x64dd(%rip), %rsi      # 0x90e9
callq 0x10e0
movq %rax, %rdi
callq 0x10a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x6358
xorb $-0x80, 0x13(%rbx)
addl $0x8000, 0x2c(%rbx)     # imm = 0x8000
xorb $-0x80, 0x3b(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: operator<<(std::ostream&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
ostream& operator<<(ostream& out, const vector<string>& v)
{
    out << "[";
    for (auto it=v.begin(); it!=v.end(); ++it) {
        out << *it;
        if (it + 1 != v.end())
            out << ", ";
    }
    out << "]";
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c17(%rip), %rsi      # 0x404b
callq 0x21b0
movq (%r14), %r15
leaq 0x1bc1(%rip), %r12      # 0x4004
cmpq 0x8(%r14), %r15
je 0x246b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2190
addq $0x20, %r15
cmpq 0x8(%r14), %r15
je 0x2443
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21b0
jmp 0x2443
leaq 0x1b95(%rip), %rsi      # 0x4007
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: trimmed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string trimmed(const string& str, const string& rem=" ")
{
    string::size_type begin = str.find_first_not_of(rem);
    if (begin == string::npos)
        return "";
    return str.substr(begin, str.find_last_not_of(rem) - begin + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x2170
cmpq $-0x1, %rax
je 0x2538
movq %rax, %r12
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c0
subq %r12, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x21e0
jmp 0x254b
leaq 0x1b75(%rip), %rsi      # 0x40b4
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x2e70
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool readFile(const string& path, vector<string>& lines)
{
    ifstream file(path);
    if (!file)
        return false;

    string line;
    while (getline(file, line))
        lines.push_back(trimmed(line));
    return !file.bad();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x298(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2280
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x278(%rbp,%rax)
je 0x259f
xorl %ebx, %ebx
jmp 0x263b
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x50(%rbp), %r15
leaq -0x70(%rbp), %r13
leaq -0x29(%rbp), %r12
leaq -0x90(%rbp), %r14
leaq -0x298(%rbp), %rdi
movq %r15, %rsi
callq 0x2030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x261c
movq %r13, %rdi
leaq 0x1a1c(%rip), %rsi      # 0x4005
movq %r12, %rdx
callq 0x2e70
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x24e5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x322c
movq %r14, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
jmp 0x25c2
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x1, -0x278(%rbp,%rax)
sete %bl
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x298(%rbp), %rdi
callq 0x2060
movl %ebx, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x20d0
jmp 0x266f
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20d0
jmp 0x267f
jmp 0x267c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20d0
leaq -0x298(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: parseAdjacent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Target&)
void parseAdjacent(string adj, Target& tgt)
{
    string::size_type pos;

    while ((pos = adj.find(" ")) != string::npos) {
        string token = adj.substr(0, pos);
        adj.erase(0, pos + 1);
        if (token.size())
            tgt.adjacent.push_back(token);
    }

    if (adj.size())
        tgt.adjacent.push_back(adj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rbx
leaq 0x1877(%rip), %r15      # 0x4005
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22d0
cmpq $-0x1, %rax
je 0x27e4
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
incq %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2050
cmpq $0x0, -0x40(%rbp)
je 0x27da
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2eac
movq %r12, %rdi
callq 0x20d0
jmp 0x2792
cmpq $0x0, 0x8(%r14)
je 0x27f6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2eac
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: parseTask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool parseTask(const string& t, vector<string>& tasks)
{
    if (t.find_first_not_of(' ') == string::npos)
        return true;
    if (t.at(0) != '\t')
        return false;

    tasks.push_back(t.substr(1));
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rsi
xorl %edx, %edx
callq 0x21a0
movb $0x1, %r15b
cmpq $-0x1, %rax
je 0x287d
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x21f0
cmpb $0x9, (%rax)
jne 0x287d
leaq -0x38(%rbp), %r15
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x21e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x322c
leaq -0x38(%rbp), %rdi
callq 0x20d0
movb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: topologicalSort(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Target, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Target>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void topologicalSort
(
    TargetMap& nodes,
    const string& id,
    StringSet& visited,
    vector<string>& order
)
{
    if (visited.find(id) != visited.end())
        return;

    visited.emplace(id);
    for (const string& adj : nodes.at(id).adjacent)
        topologicalSort(nodes, adj, visited, order);
    order.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rdx, %rdi
callq 0x3a7e
testq %rax, %rax
je 0x2a60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b5c
movq %r12, %rdi
movq %r14, -0x30(%rbp)
movq %r14, %rsi
callq 0x3a30
movq 0x20(%rax), %r13
movq 0x28(%rax), %r14
cmpq %r14, %r13
je 0x2a9e
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2a2a
addq $0x20, %r13
jmp 0x2a82
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2eac
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: doTask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool doTask(string task)
{
    cout << "@" << task << endl;
    char * const argv[] = {
        (char *) "/bin/bash",
        (char *) "-c",
        (char *) task.c_str(),
        NULL
    };

    int status;
    pid_t child = fork();

    if (child == -1) {
        perror("fork");
        return false;
    } else if (!child) {
        execvp("bash", argv);
        perror("execvp");
        exit(1);
    }

    if (wait(&status) == -1) {
        perror("wait");
        return false;
    }
    return WIFEXITED(status) && WEXITSTATUS(status) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x447e(%rip), %rdi      # 0x6fd0
leaq 0x1500(%rip), %rsi      # 0x4059
callq 0x21b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x20e0
leaq 0x14e3(%rip), %rax      # 0x405b
movq %rax, -0x30(%rbp)
leaq 0x14e2(%rip), %rax      # 0x4065
movq %rax, -0x28(%rbp)
movq (%rbx), %rax
movq %rax, -0x20(%rbp)
andq $0x0, -0x18(%rbp)
callq 0x2070
cmpl $-0x1, %eax
je 0x2bc1
testl %eax, %eax
je 0x2bda
leaq -0xc(%rbp), %rdi
callq 0x2210
cmpl $-0x1, %eax
je 0x2bca
movzwl -0xc(%rbp), %eax
testw $0xff7f, %ax            # imm = 0xFF7F
sete %al
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x14a0(%rip), %rdi      # 0x4068
jmp 0x2bd1
leaq 0x14a3(%rip), %rdi      # 0x4074
callq 0x2160
xorl %eax, %eax
jmp 0x2bba
leaq 0x147f(%rip), %rdi      # 0x4060
leaq -0x30(%rbp), %rsi
callq 0x2130
leaq 0x147c(%rip), %rdi      # 0x406d
callq 0x2160
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: processTarget(Target&)
bool processTarget(Target& tgt)
{
    for (const string& task : tgt.tasks) {
        if (!doTask(task)) {
            taskError(task);
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x38(%rdi), %rbx
movq 0x40(%rdi), %r12
leaq -0x40(%rbp), %r14
cmpq %r12, %rbx
je 0x2c4f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x2b3f
movl %eax, %r15d
movq %r14, %rdi
callq 0x20d0
testb %r15b, %r15b
je 0x2c47
addq $0x20, %rbx
jmp 0x2c19
movq %rbx, %rdi
callq 0x2730
cmpq %r12, %rbx
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: processTargets(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Target, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Target>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool processTargets(TargetMap& nodes, vector<string>& order)
{
    for (const string& name : order) {
        if (!processTarget(nodes.at(name))) {
            targetError(name);
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
movq 0x8(%rsi), %r15
cmpq %r15, %rbx
je 0x2cb4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a30
movq %rax, %rdi
callq 0x2bfe
testb %al, %al
je 0x2cac
addq $0x20, %rbx
jmp 0x2c8a
movq %rbx, %rdi
callq 0x26f4
cmpq %r15, %rbx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j84guo[P]cake/cake.cpp
// Function: main
int main()
{
    vector<string> lines;
    if (!readFile("Cakefile", lines)) {
        perror("readFile");
        return 1;
    }

    TargetMap nodes;
    if (!parseTargets(nodes, lines))
        return 1;

    vector<string> order;
    sortTargets(nodes, order);

    cout << "[...Target Order...]\n";
    for (auto& name : order)
        cout << name << "\n";

    cout << "[...Processing...]\n";
    return processTargets(nodes, order) ? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
leaq 0x138f(%rip), %rsi      # 0x4079
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x2e70
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x255b
movl %eax, %ebx
leaq -0x98(%rbp), %rdi
callq 0x20d0
testb %bl, %bl
je 0x2e18
leaq -0x68(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x289f
testb %al, %al
je 0x2dbb
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq -0x98(%rbp), %rdi
callq 0x2ab8
movq 0x4258(%rip), %rdi      # 0x6fd0
leaq 0x130c(%rip), %rsi      # 0x408b
callq 0x21b0
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r12
movq 0x423d(%rip), %r14      # 0x6fd0
leaq 0x1319(%rip), %r15      # 0x40b3
cmpq %r12, %rbx
je 0x2dc0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2190
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
addq $0x20, %rbx
jmp 0x2d9a
pushq $0x1
popq %rbx
jmp 0x2df1
movq 0x4209(%rip), %rdi      # 0x6fd0
leaq 0x12d3(%rip), %rsi      # 0x40a1
callq 0x21b0
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2c76
xorb $0x1, %al
movzbl %al, %ebx
leaq -0x40(%rbp), %rdi
callq 0x2ee8
leaq -0x98(%rbp), %rdi
callq 0x3000
leaq -0x60(%rbp), %rdi
callq 0x2ee8
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1263(%rip), %rdi      # 0x4082
callq 0x2160
pushq $0x1
popq %rbx
jmp 0x2dfd
movq %rax, %rbx
jmp 0x2e52
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x20d0
jmp 0x2e5e
movq %rax, %rbx
jmp 0x2e5e
jmp 0x2e46
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2ee8
leaq -0x98(%rbp), %rdi
callq 0x3000
leaq -0x60(%rbp), %rdi
callq 0x2ee8
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 3ul>(std::shared_ptr<swxJson::Json>, char const*, char const*, bool)
void test_array(JsonPtr json, const char* key, const char* desc, bool compatibleMode)
{
	cout<<endl<<desc<<endl;

	std::array<K, N> elemArray = (*json)[key].wantArray<K, N>(compatibleMode);
	for (auto& element: elemArray)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1c99a(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
movq %rsp, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x1e448
xorl %r15d, %r15d
leaq 0xff91(%rip), %r14      # 0x2c60d
cmpq $0x60, %r15
je 0x1c6a7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a280
leaq (%rsp,%r15), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
addq $0x20, %r15
jmp 0x1c67c
movq %rsp, %rdi
callq 0x1e5be
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1e5be
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_queue(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::queue<K> elemQueue = (*json)[key].wantQueue<K>();
	while (elemQueue.size())
	{
		cout<<"Element: "<<elemQueue.front()<<endl;
		elemQueue.pop();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1c5c0(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1ed56
leaq 0xfbb7(%rip), %r15      # 0x2c60d
movq %r14, %rdi
callq 0x1f148
testq %rax, %rax
je 0x1ca8d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a280
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
movq %r14, %rdi
callq 0x1f2e0
jmp 0x1ca56
leaq 0x8(%rsp), %rdi
callq 0x1f34a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f34a
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_deque<int>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_deque(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::deque<K> elemQueue = (*json)[key].wantDeque<K>();
	while (elemQueue.size())
	{
		cout<<"Element: "<<elemQueue.front()<<endl;
		elemQueue.pop_front();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1c38d(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fb60
leaq 0xf984(%rip), %r15      # 0x2c60d
movq %r14, %rdi
callq 0x1f844
testq %rax, %rax
je 0x1ccc2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a280
movq 0x18(%rsp), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x1a400
movq %rax, %rdi
callq 0x1a100
movq %r14, %rdi
callq 0x1f9dc
jmp 0x1cc89
leaq 0x8(%rsp), %rdi
callq 0x1fa32
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fa32
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_list(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::list<K> elemList = (*json)[key].wantList<K>();
	for (auto& element: elemList)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1c2d0(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fc4a
leaq 0xf8c9(%rip), %r15      # 0x2c60d
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x1cd72
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a280
leaq 0x10(%r12), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
jmp 0x1cd47
movq %rsp, %rdi
callq 0x1fe28
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1fe28
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_vector<int>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_vector(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::vector<K> elemVector = (*json)[key].wantVector<K>();
	for (auto& element: elemVector)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1c0ca(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x203da
movq (%r14), %r15
movq 0x8(%r14), %r12
leaq 0xf6bc(%rip), %r14      # 0x2c60d
cmpq %r12, %r15
je 0x1cf7a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a280
movl (%r15), %esi
movq %rax, %rdi
callq 0x1a400
movq %rax, %rdi
callq 0x1a100
addq $0x4, %r15
jmp 0x1cf51
movq %rsp, %rdi
callq 0x206c6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x206c6
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_set(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::set<K> elemSet = (*json)[key].wantSet<K>();
	for (auto& element: elemSet)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1c01c(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x206e4
movq 0x18(%r14), %r15
leaq 0x10(%rsp), %r12
leaq 0xf60a(%rip), %r14      # 0x2c60d
cmpq %r12, %r15
je 0x1d034
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a280
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
movq %r15, %rdi
callq 0x1a2e0
movq %rax, %r15
jmp 0x1d003
leaq 0x8(%rsp), %rdi
callq 0x209b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209b0
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_unordered_set(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::unordered_set<K> elemSet = (*json)[key].wantUnorderedSet<K>();
	for (auto& element: elemSet)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1bea0(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
movq %rsp, %rdi
movq %rax, %rsi
callq 0x20cbc
leaq 0x10(%rsp), %r15
leaq 0xf497(%rip), %r14      # 0x2c60d
movq (%r15), %r15
testq %r15, %r15
je 0x1d19f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a280
leaq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
jmp 0x1d176
movq %rsp, %rdi
callq 0x2124c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2124c
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_dict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_dict(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::map<std::string, K> elemMap = (*json)[key].wantDict<K>();
	for (auto& pp: elemMap)
		cout<<"Element: "<<pp.first<<":"<<pp.second<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1bd4c(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x217bc
movq 0x18(%r14), %r12
leaq 0x8(%rsp), %r13
leaq 0xf33c(%rip), %r14      # 0x2c60d
leaq 0xf4a2(%rip), %r15      # 0x2c77a
cmpq %r13, %r12
je 0x1d322
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a280
leaq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a280
leaq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
movq %r12, %rdi
callq 0x1a180
movq %rax, %r12
jmp 0x1d2d8
movq %rsp, %rdi
callq 0x21d30
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21d30
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch.cpp
// Function: void test_unordered_dict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_unordered_dict(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::unordered_map<std::string, K> elemMap = (*json)[key].wantUnorderedDict<K>();
	for (auto& pp: elemMap)
		cout<<"Element: "<<pp.first<<":"<<pp.second<<endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x1bb96(%rip), %rbx     # 0x38fd8
movq %rbx, %rdi
callq 0x1a100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a280
movq %rax, %rdi
callq 0x1a100
movq (%r12), %rdi
movq %r15, %rsi
callq 0x2632a
movq %rsp, %rdi
movq %rax, %rsi
callq 0x222f0
leaq 0x10(%rsp), %r12
leaq 0xf18d(%rip), %r14      # 0x2c60d
leaq 0xf2f3(%rip), %r15      # 0x2c77a
movq (%r12), %r12
testq %r12, %r12
je 0x1d4ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a280
leaq 0x8(%r12), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a280
leaq 0x28(%r12), %rsi
movq %rax, %rdi
callq 0x1a240
movq %rax, %rdi
callq 0x1a100
jmp 0x1d487
movq %rsp, %rdi
callq 0x22848
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22848
movq %rbx, %rdi
callq 0x1a410
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/TestClient/TestClient.cpp
// Function: init()
void init()
{
    fd = socket(AF_INET, SOCK_STREAM, 0);
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    inet_aton("127.0.0.1", &(addr.sin_addr));
    addr.sin_port = htons(7788);
    int ret = connect(fd, (struct sockaddr*)&addr, sizeof(sockaddr));
    client = new Client(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2050
movl %eax, 0x2d5f(%rip)      # 0x5134
xorps %xmm0, %xmm0
movups %xmm0, 0x2d59(%rip)     # 0x5138
leaq 0x2d52(%rip), %rbx      # 0x5138
movw $0x2, 0x2d49(%rip)      # 0x5138
leaq 0xc2a(%rip), %rdi       # 0x3020
leaq 0x2d3f(%rip), %rsi      # 0x513c
callq 0x20c0
movw $0x6c1e, 0x2d2f(%rip)   # imm = 0x6C1E
movl 0x2d23(%rip), %edi      # 0x5134
pushq $0x10
popq %rdx
movq %rbx, %rsi
callq 0x20d0
movl $0x2024, %edi           # imm = 0x2024
callq 0x2120
andq $0x0, 0x1004(%rax)
andl $0x0, 0x100c(%rax)
andq $0x0, 0x2014(%rax)
andl $0x0, 0x201c(%rax)
movl 0x2cea(%rip), %ecx      # 0x5134
movl %ecx, 0x2020(%rax)
movq %rax, 0x2cf1(%rip)      # 0x5148
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/TestClient/TestClient.cpp
// Function: recv_thread()
void recv_thread()
{
    PacketInfo pi;
    string content;
    for (;;) {
        int ret = client->Recv();
        bool flag = client->hasMsg(&pi, content);
        if (flag) {
            cout << "Recv: ";
            cout << content << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x58(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq 0x2b44(%rip), %r15      # 0x4fd0
leaq 0xb97(%rip), %r12       # 0x302a
movq 0x2cae(%rip), %rdi      # 0x5148
callq 0x27a8
movq 0x2ca2(%rip), %rdi      # 0x5148
movq %rbx, %rsi
movq %r14, %rdx
callq 0x281e
testb %al, %al
je 0x2493
movq %r15, %rdi
movq %r12, %rsi
callq 0x2110
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20a0
jmp 0x2493
jmp 0x24d7
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/fieryzig[P]GameServer/TestClient/TestClient.cpp
// Function: main
int main()
{
    init();
    Client* client = new Client(fd);

    PacketInfo pi;
    pi.srcType = ServerType::CLIENT;
    pi.time = time(NULL);
    pi.uid = -1;
    pi.svrid = 0;
    pi.clifd = -1;
    pi.contentLen = 5;
    string content = "Login";
    client->Send(pi, content);

//    thread recvThread(recv_thread);

    for(;;)
    {
        cin >> content;
        pi.time = time(NULL);
        pi.contentLen = content.length();
        int ret = client->Send(pi, content);
        while (client->hasRemain()) client->SendRemain();
        if (content == "Logout") {
            close(client->fd);
            return 0;
        }
    }

//    recvThread.join();

    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
callq 0x23bc
movl $0x2024, %edi           # imm = 0x2024
callq 0x2120
movq %rax, %rbx
andq $0x0, 0x1004(%rax)
andl $0x0, 0x100c(%rax)
movl 0x2c0e(%rip), %eax      # 0x5134
andq $0x0, 0x2014(%rbx)
andl $0x0, 0x201c(%rbx)
movl %eax, 0x2020(%rbx)
xorl %edi, %edi
callq 0x2100
movq %rax, %r14
leaq 0xae5(%rip), %rsi       # 0x3031
leaq -0x80(%rbp), %r15
leaq -0x29(%rbp), %rdx
movq %r15, %rdi
callq 0x2080
andl $0x0, -0x60(%rbp)
movl %r14d, -0x5c(%rbp)
movaps 0xaa5(%rip), %xmm0      # 0x3010
movups %xmm0, -0x58(%rbp)
leaq -0xa0(%rbp), %rdi
movq %r15, %rsi
callq 0x2160
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x60(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x293a
leaq -0xa0(%rbp), %rdi
callq 0x2090
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leaq -0xc0(%rbp), %r12
leaq 0xa79(%rip), %r13       # 0x3037
movq 0x2a1b(%rip), %rdi      # 0x4fe0
movq %r15, %rsi
callq 0x2150
xorl %edi, %edi
callq 0x2100
andl $0x0, -0x48(%rbp)
movl -0x78(%rbp), %ecx
movl %eax, -0x44(%rbp)
movq %r14, -0x40(%rbp)
orl $-0x1, -0x38(%rbp)
movl %ecx, -0x34(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2160
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x48(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x293a
movq %r12, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2a46
testb %al, %al
je 0x262e
movq %rbx, %rdi
callq 0x2a56
jmp 0x2618
movq %r15, %rdi
movq %r13, %rsi
callq 0x269e
testb %al, %al
je 0x25be
movl 0x2020(%rbx), %edi
callq 0x2210
leaq -0x80(%rbp), %rdi
callq 0x2090
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x268a
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
jmp 0x2683
jmp 0x268a
jmp 0x268a
jmp 0x268a
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x2090
jmp 0x268d
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/flastest[P]HeterogeneousParallelDijkstra/./graph_gen.hh
// Function: generate_graph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void generate_graph(std::string file_name, int number_of_nodes, int number_of_edges)
{
	srand(time(0));
	ofstream file_stream;
	file_stream.open (file_name);

	file_stream << "# a graph with "<< number_of_nodes << " nodes and " << number_of_edges << " edges.\n";
	file_stream << "# in general, I saw it was good to have 5 times as many edges as nodes to get a fully connected graph.\n";


	for (int i = 1; i <= number_of_edges; i++)
	{
    int point_a = rand() % number_of_nodes;
    int point_b = (rand() % number_of_nodes);
    //std::cout<<"point_a is "<<point_a<<std::endl;
    if (point_b == point_a)
    {
    //    std::cout<<"point_b is "<<point_b<<std::endl;
        point_b =(point_b + 1) % number_of_nodes;
    //    std::cout<<"point_b is changed to "<<point_b<<std::endl;

    } 
		file_stream << 	to_string(point_a) << " " << to_string(point_b);
		if (i < number_of_edges) file_stream << "\n";
	}

	file_stream.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movl %edx, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x4270
movl %eax, %edi
callq 0x4280
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x4420
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4140
leaq 0x9a0e(%rip), %rsi      # 0xe124
leaq 0x58(%rsp), %rdi
callq 0x4290
movq %rax, %rdi
movl %ebp, %esi
callq 0x4460
leaq 0x9a03(%rip), %rsi      # 0xe134
movq %rax, %rdi
callq 0x4290
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x4460
leaq 0x99f4(%rip), %rsi      # 0xe140
movq %rax, %rdi
callq 0x4290
leaq 0x99ee(%rip), %rsi      # 0xe149
leaq 0x58(%rsp), %rdi
callq 0x4290
xorl %ecx, %ecx
movl 0xc(%rsp), %eax
testl %eax, %eax
cmovgl %eax, %ecx
negl %ecx
movq %rcx, 0x10(%rsp)
pushq $0x1
popq %r15
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %r13
movq 0x10(%rsp), %rax
addl %r15d, %eax
cmpl $0x1, %eax
je 0x4827
callq 0x40a0
cltd
idivl %ebp
movl %edx, %ebx
callq 0x40a0
cltd
idivl %ebp
movl %edx, %r12d
cmpl %ebx, %edx
jne 0x47b8
leal 0x1(%rbx), %eax
cltd
idivl %ebp
movl %edx, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x8794
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x4250
movq %rax, %rdi
leaq 0x9b7f(%rip), %rsi      # 0xe358
callq 0x4290
movq %rax, %rbx
movq %r13, %rdi
movl %r12d, %esi
callq 0x8794
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4250
movq %r13, %rdi
callq 0x4120
movq %r14, %rdi
callq 0x4120
cmpl 0xc(%rsp), %r15d
jge 0x481f
leaq 0x58(%rsp), %rdi
leaq 0x9995(%rip), %rsi      # 0xe1af
callq 0x4290
incl %r15d
jmp 0x4785
leaq 0x58(%rsp), %rdi
callq 0x4360
leaq 0x58(%rsp), %rdi
callq 0x43a0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4862
jmp 0x4862
jmp 0x4867
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4120
jmp 0x486a
movq %rax, %rbx
jmp 0x4874
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4120
leaq 0x58(%rsp), %rdi
callq 0x43a0
movq %rbx, %rdi
callq 0x4470