LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/sci_dec.cc
// Function: main
int main() 
{
	cout << "default format: " << 100 * sqrt(2.0) << '\n'
		 << "scientific: " << scientific << 100 * sqrt(2.0) << '\n'
	     << "fixed decimal: " << fixed << 100 * sqrt(2.0) << '\n'
#ifdef HEX_MANIPS     // no workaround for this missing manipulator
		 << "hexadecimal: " << hexfloat << 100 * sqrt(2.0) << '\n'
#endif
		 << "use defaults: " << defaultfloat << 100 * sqrt(2.0) 
		 << "\n\n";
	
	cout << uppercase
	     << "scientific: " << scientific << sqrt(2.0) << '\n'
	     << "fixed decimal: " << fixed << sqrt(2.0) << '\n'
#ifdef HEX_MANIPS     // no workaround for this missing manipulator
		 << "hexadecimal: " << hexfloat << sqrt(2.0) << "\n\n"
#endif
		 << nouppercase;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2e07(%rip), %r14      # 0x3fd8
leaq 0xe40(%rip), %rsi       # 0x2018
movq %r14, %rdi
callq 0x1040
movsd 0xe20(%rip), %xmm0      # 0x2008
movq %rax, %rdi
callq 0x1070
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x1050
leaq 0xe25(%rip), %rsi       # 0x2029
movq %rax, %rdi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl $0xfffffefb, %r13d      # imm = 0xFFFFFEFB
movl 0x18(%rax,%rcx), %edx
andl %r13d, %edx
movl $0x100, %r15d           # imm = 0x100
orl %r15d, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movsd 0xdd0(%rip), %xmm0      # 0x2008
callq 0x1070
movq %rax, %rdi
movl %ebx, %esi
callq 0x1050
leaq 0xde8(%rip), %r12       # 0x2036
movq %rax, %rdi
movq %r12, %rsi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl %r13d, %edx
orl $0x4, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movsd 0xd8f(%rip), %xmm0      # 0x2008
callq 0x1070
movq %rax, %rdi
movl %ebx, %esi
callq 0x1050
leaq 0xdb7(%rip), %rsi       # 0x2046
movq %rax, %rdi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andl %r13d, 0x18(%rax,%rcx)
movq %rax, %rdi
movsd 0xd5a(%rip), %xmm0      # 0x2008
callq 0x1070
leaq 0xd9b(%rip), %rsi       # 0x2055
movq %rax, %rdi
callq 0x1040
movq (%r14), %rax
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%r14,%rax) # imm = 0x4000
movq %r14, %rdi
leaq 0xd4d(%rip), %rsi       # 0x2029
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl %r13d, %edx
orl %r15d, %edx
movl %edx, 0x18(%rax,%rcx)
movsd 0xd12(%rip), %xmm0      # 0x2010
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
movl %ebx, %esi
callq 0x1050
movq %rax, %rdi
movq %r12, %rsi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andl 0x18(%rax,%rcx), %r13d
orl $0x4, %r13d
movl %r13d, 0x18(%rax,%rcx)
movq %rax, %rdi
movsd 0xcd5(%rip), %xmm0      # 0x2010
callq 0x1070
movq %rax, %rdi
movl %ebx, %esi
callq 0x1050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andl $0xffffbfff, 0x18(%rax,%rcx) # imm = 0xFFFFBFFF
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/../../CH01_GettingStarted/examples/Sales_item.h
// Function: operator>>(std::istream&, Sales_item&)
std::istream&
operator>>(std::istream& in, Sales_item& s)
{
    double price;
    in >> s.bookNo >> s.units_sold >> price;
    // check that the inputs succeeded
    if (in)
        s.revenue = s.units_sold * price;
    else
        s = Sales_item();  // input failed: reset object to default state
    return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2130
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x21a0
leaq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x23c1
leaq -0x40(%rbp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, 0x10(%rax)
leaq -0x50(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e32
movq %r15, %rdi
callq 0x2070
jmp 0x23d5
movl 0x20(%r14), %eax
cvtsi2sd %rax, %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: TouchFile(char const*)
bool TouchFile(const char* filename) {
	std::ifstream ifs(filename);
	if (!ifs.is_open()) {
		fprintf(stderr, "File [%s] not exsit.\n", filename);
		exit(-1);
	}
	ifs.close();
}

// Assembly:
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x2320
leaq 0x80(%rsp), %rdi
callq 0x2090
testb %al, %al
je 0x2522
leaq 0x8(%rsp), %rdi
callq 0x2080
movq 0x4aaf(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x1b0d(%rip), %rsi      # 0x4040
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22a0
pushq $-0x1
popq %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: ExecCmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int ExecCmd(string cmd, string& res) {
	if (cmd.size() == 0) {  //cmd is empty 
		return -1;
	}

	char buffer[1024] = { 0 };
	string result = "";
	FILE* pin = popen(cmd.c_str(), "r");
	if (!pin) { //popen failed 
		return -1;
	}

	res.clear();
	while (!feof(pin)) {
		if (fgets(buffer, sizeof(buffer), pin) != NULL) {
			result += buffer;
		}
	}

	res = result;
	return pclose(pin); //-1:pclose failed; else shell ret
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
cmpq $0x0, 0x8(%rdi)
je 0x2613
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x2150
leaq 0x1ad9(%rip), %rsi      # 0x406a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3098
movq (%r14), %rdi
leaq 0x1aac(%rip), %rsi      # 0x4056
callq 0x20c0
testq %rax, %rax
je 0x2618
movq %rax, %r14
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %r14, %rdi
callq 0x22d0
testl %eax, %eax
jne 0x25fa
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x22e0
testq %rax, %rax
je 0x25cc
movq %r12, %rdi
movq %r15, %rsi
callq 0x2330
jmp 0x25cc
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
movl %eax, %ebx
jmp 0x261b
pushq $-0x1
popq %rbx
jmp 0x2625
pushq $-0x1
popq %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movl %ebx, %eax
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2638
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: SplitStringToVect(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>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int SplitStringToVect(const string& srcStr, vector<string>& destVect, const string& strFlag)
{
	int pos = srcStr.find(strFlag, 0);
	int startPos = 0;
	int splitN = pos;
	string lineText(strFlag);

	while (pos > -1)
	{
		lineText = srcStr.substr(startPos, splitN);
		startPos = pos + 1;
		pos = srcStr.find(strFlag, pos + 1);
		splitN = pos - startPos;
		destVect.push_back(lineText);
	}

	lineText = srcStr.substr(startPos, srcStr.length() - startPos);
	destVect.push_back(lineText);

	return destVect.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
xorl %ebp, %ebp
movq %rdx, %rsi
xorl %edx, %edx
callq 0x2360
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq %r15, 0x10(%rsp)
movq %r15, %rsi
callq 0x2280
leaq 0x38(%rsp), %r13
movl %ebx, %r15d
movl %ebp, %edx
testl %ebx, %ebx
js 0x26e7
movslq %r15d, %rcx
movq %r13, %rdi
movq %r14, %rsi
callq 0x2200
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2240
movq %r13, %rdi
callq 0x2110
movl %ebx, %ebp
incl %ebp
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0x2360
movq %rax, %rbx
movl %ebx, %r15d
subl %ebp, %r15d
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x30d4
jmp 0x268f
movq 0x8(%r14), %rcx
subq %rdx, %rcx
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x2200
leaq 0x18(%rsp), %rbx
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x2110
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30d4
movq 0x8(%r14), %rbx
subq (%r14), %rbx
shrq $0x5, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2110
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2754
jmp 0x2754
jmp 0x2754
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::Program::GetFuncNameFromStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int MyPaser::Program::GetFuncNameFromStr(const string& context) {
	vector<string> lines;
	lines.clear();
	SplitStringToVect(context, lines, "\n");

	for (auto &l : lines) {
		if (l.find("g     F .text") != string::npos) {
			int pos = l.find_last_of(" ");
			string funcName = l.substr(pos + 1, l.size() - pos);
			//cout << l << ":" << funcName << endl;
			//cout << funcName << endl;
			this->funcName_.push_back(funcName);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x3100
leaq 0x18ba(%rip), %rsi      # 0x4054
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3098
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x264d
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2110
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r13
leaq 0x187f(%rip), %r12      # 0x4058
pushq $-0x1
popq %rbp
cmpq %r13, %r15
je 0x2839
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2350
cmpq $-0x1, %rax
je 0x2833
movq %r15, %rdi
leaq 0x1868(%rip), %rsi      # 0x4066
movq %rbp, %rdx
callq 0x21c0
leal 0x1(%rax), %ecx
movslq %ecx, %rdx
movq 0x8(%r15), %rcx
cltq
subq %rax, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30d4
movq %r14, %rdi
callq 0x2110
addq $0x20, %r15
jmp 0x27dc
leaq 0x10(%rsp), %rdi
callq 0x3108
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2858
jmp 0x2867
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2110
jmp 0x286a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3108
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: SplitDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string SplitDirectory(string fulldir) {
	int pos = fulldir.find_last_of("/");
	//cout << pos << endl;
	if (pos == string::npos) {
		return fulldir;
	}
	else {
		return fulldir.substr(pos+1, fulldir.size() - pos);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15ce(%rip), %rsi      # 0x406b
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x21c0
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
cmpq %rcx, %rax
jne 0x2ac8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
jmp 0x2af2
movq %rax, %rsi
sarq $0x20, %rsi
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rax, %rdx
sarq $0x20, %rdx
movq 0x8(%r14), %rcx
subq %rsi, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::Program::PrintfFuncOptoFile(char const*)
void MyPaser::Program::PrintfFuncOptoFile(const char* filename) {
	FILE* f = fopen(filename, "w");
	for (auto &name : this->funcName_) {
		fprintf(f, "[%s]:\n", name.c_str());
		for (auto &op : this->functOp_[name]) {
			fprintf(f, "%s,", op.c_str());
		}
		fprintf(f, "\n");
	}
	fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r12
leaq 0x1557(%rip), %rsi      # 0x406d
movq %rax, %rdi
callq 0x2220
movq %rax, %r14
movq (%r12), %r15
movq 0x8(%r12), %rax
movq %rax, (%rsp)
addq $0x18, %r12
leaq 0x153d(%rip), %r13      # 0x4076
cmpq (%rsp), %r15
je 0x2b92
movq (%r15), %rdx
movq %r14, %rdi
leaq 0x1523(%rip), %rsi      # 0x406f
xorl %eax, %eax
callq 0x22a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x312a
movq (%rax), %rbp
movq 0x8(%rax), %rbx
cmpq %rbx, %rbp
je 0x2b81
movq (%rbp), %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x22a0
addq $0x20, %rbp
jmp 0x2b65
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x2250
addq $0x20, %r15
jmp 0x2b39
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::MaxFlow(MyPaser::Program&, MyPaser::Program&)
int MyPaser::GetFuncList(char* filename, Program& Prog) {
	char cmd[1000];
	string cmdres;

	sprintf(cmd, "mktemp");
	ExecCmd(cmd, cmdres);
	char tempFilename[50];
	strcpy(tempFilename, cmdres.c_str());
	//cout << tempFilename << endl;

	sprintf(cmd, "g++ -std=c++11 -O2 -c %s -o %s", filename, tempFilename);
	ExecCmd(cmd, cmdres);

	sprintf(cmd, "objdump -t %s", tempFilename);
	ExecCmd(cmd, cmdres);
	Prog.GetFuncNameFromStr(cmdres);
	//printf("%s\n", cmdres.c_str());

	//FILE* f = fopen("1.txt", "w");
	//fprintf(f, "%s", cmdres.c_str());
	//fclose(f);

	sprintf(cmd, "objdump --no-show-raw-insn -d %s", tempFilename);
	ExecCmd(cmd, cmdres);
	Prog.GetFuncOpFromStr(cmdres);

	/*string t = filename;
	if (t.find("a.cpp") != string::npos) {
		Prog.PrintfFuncOptoFile("A_op.txt");
	}
	else {
		Prog.PrintfFuncOptoFile("B_op.txt");
	}

	//f = fopen("2.txt", "w");
	//fprintf(f, "%s", cmdres.c_str());
	//fclose(f);
	//*/
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xf0(%rsp), %rsi
movl $0x65746b6d, (%rsi)     # imm = 0x65746B6D
movl $0x706d65, 0x3(%rsi)    # imm = 0x706D65
leaq 0x90(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x3098
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x255a
leaq 0x90(%rsp), %rdi
callq 0x2110
movq 0x10(%rsp), %rsi
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
callq 0x21b0
leaq 0x116e(%rip), %rsi      # 0x4081
leaq 0xf0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2070
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r12, %rsi
callq 0x3098
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x255a
leaq 0x70(%rsp), %rdi
callq 0x2110
leaq 0x1143(%rip), %rsi      # 0x40a0
leaq 0xf0(%rsp), %r14
leaq 0xb0(%rsp), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2070
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x3098
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x255a
leaq 0x50(%rsp), %rdi
callq 0x2110
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x276a
leaq 0x10f8(%rip), %rsi      # 0x40ae
leaq 0xf0(%rsp), %r14
leaq 0xb0(%rsp), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2070
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x3098
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x255a
leaq 0x30(%rsp), %rdi
callq 0x2110
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x287c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x3039
jmp 0x3040
jmp 0x3040
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x3039
jmp 0x3040
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x3039
jmp 0x3040
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x2110
jmp 0x3043
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/MyPaser.cpp
// Function: MyPaser::Compare(MyPaser::Program&, MyPaser::Program&)
double MyPaser::PaserCompare(char* filename1, char* filename2) {
	MyPaser::Program A;
	MyPaser::Program B;

	if (TouchFile(filename1) && TouchFile(filename2)) {
		GetFuncList(filename1, A);
		GetFuncList(filename2, B);

		return max(Compare(A, B), Compare(B, A));
		//9return  Compare(A, B);

		//printf("%s\n", filename1);
		//string s = SplitDirectory(filename1);
		//printf("%s\n", s.c_str());
	}
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x31ba
movq %rsp, %rdi
callq 0x31ba
movq %rbx, %rdi
callq 0x24ec
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31f2
leaq 0x48(%rsp), %rdi
callq 0x31f2
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/mxy161610207[P]codesim/src/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    char* filename1, *filename2;
    if (argc == 3) {
        filename1 = argv[1];
        filename2 = argv[2];
    }
    else {
        ShowHelp();
        exit(-1);
    }

    double res = MyPaser::PaserCompare(filename1, filename2);
    res = min(res, 1.0);
    printf("%.2lf\n", res);

    return 0;
}

// Assembly:
pushq %rax
cmpl $0x3, %edi
jne 0x3bd9
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
callq 0x3055
movsd 0x589(%rip), %xmm1      # 0x4148
minsd %xmm0, %xmm1
leaq 0x5bd(%rip), %rdi       # 0x4187
movapd %xmm1, %xmm0
movb $0x1, %al
callq 0x2050
xorl %eax, %eax
popq %rcx
retq
callq 0x3b88
pushq $-0x1
popq %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/lhartmann[P]orangepi-i2s-steppers/cnt.cpp
// Function: step()
uint32_t step() {
	uint32_t out = 0;
	
	// If motion has completed, prepare new move
	bool done = throttle.done();
	for (int s=0; s<NUM_STEPPERS; ++s) done = done && stepper[s].done();
	
	if (done) {
		// Reverse direction
		if (++forward == 16) forward = 0;
		
		// Move Duration (samples), considering max-speed.
		// Beware of this expression, RATE*MOVE may overflow.
		uint32_t duration = RATE * 1. * MOVE/MAXSPD;
		
		// Prepare the speed controllers
		for (int s=0; s<NUM_STEPPERS; ++s)
			stepper[s].prepare(MOVE/(s+1), duration);
		
		// Prepare the acceleration controller
		throttle.prepare(duration, ACCEL, ACCEL/100, ACCEL/100);
	}
	
	// Render movement
	out += forward*DIR_MASK;
	if (throttle.step()) {
		for (int s=0; s<NUM_STEPPERS; ++s) {
			if (stepper[s].step()) {
				out |= STEP_MASK<<s;
			}
		}
	}
	
	// Encode for I2S output:
	//   Apply selective transport delay (31 LSBs delayed by 1 clock)
	out = td(out);
	//   Fix word clock phase by shifting bits around.
	//   Hardware will delay 1 MSB by 1 clock, resyncing the word.
	out = (out<<1) | (out>>31); 
	
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2ee0(%rip), %eax      # 0x4030
cmpl 0x2ee2(%rip), %eax      # 0x4038
sete %cl
pushq $0x4
popq %rax
leaq 0x2f2d(%rip), %rbx      # 0x4090
cmpq $0x54, %rax
je 0x1182
testb $0x1, %cl
je 0x117a
movl -0x4(%rax,%rbx), %ecx
cmpl (%rax,%rbx), %ecx
sete %cl
jmp 0x117c
xorl %ecx, %ecx
addq $0x14, %rax
jmp 0x1163
movl 0x2ef7(%rip), %r14d     # 0x4080
pushq $0x1
popq %r12
testb $0x1, %cl
je 0x1223
incl %r14d
xorl %eax, %eax
cmpl $0x10, %r14d
cmovel %eax, %r14d
movl %r14d, 0x2ed6(%rip)     # 0x4080
pushq $0x10
popq %rcx
leaq 0x2edc(%rip), %rsi      # 0x4090
movabsq $-0x752fffff15a00, %rdi # imm = 0xFFF8AD00000EA600
movl %r12d, %r8d
cmpq $0x60, %rcx
je 0x11ec
movl $0x27100, %eax          # imm = 0x27100
xorl %edx, %edx
divl %r8d
andl $0x0, -0x10(%rcx,%rsi)
movl %eax, -0xc(%rcx,%rsi)
movl %eax, -0x8(%rcx,%rsi)
movq %rdi, -0x4(%rcx,%rsi)
addq $0x14, %rcx
incl %r8d
jmp 0x11c1
movabsq $0xbb81300000000, %rax  # imm = 0xBB81300000000
movq %rax, 0x2e33(%rip)      # 0x4030
movaps 0xe0c(%rip), %xmm0      # 0x2010
movups %xmm0, 0x2e2d(%rip)     # 0x4038
movb $0x0, 0x2e3e(%rip)      # 0x4050
movabsq $-0xefffffff100, %rax   # imm = 0xFFFFF10000000F00
movq %rax, 0x2e25(%rip)      # 0x4048
shll $0x10, %r14d
leaq 0x2e02(%rip), %rdi      # 0x4030
callq 0x12d2
testb %al, %al
je 0x1265
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x1265
movq %rbx, %rdi
callq 0x1344
movl %r12d, %edx
movl %r15d, %ecx
shll %cl, %edx
testb %al, %al
cmovel %r13d, %edx
orl %edx, %r14d
incq %r15
addq $0x14, %rbx
jmp 0x123d
leaq 0x2dec(%rip), %rdi      # 0x4058
movl %r14d, %esi
callq 0x137a
roll %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lhartmann[P]orangepi-i2s-steppers/cnt.cpp
// Function: main
int main() {
	uint32_t buff[1024];
	while (true) {
		for (uint32_t i=0; i<1024; ++i) {
			buff[i] = step();
		}
		write(STDOUT_FILENO, buff, sizeof(buff));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
xorl %r15d, %r15d
pushq $0x1
popq %rbx
leaq -0x1020(%rbp), %r14
cmpq $0x400, %r15            # imm = 0x400
je 0x12bd
callq 0x113c
movl %eax, -0x1020(%rbp,%r15,4)
incq %r15
jmp 0x12a2
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
movq %r14, %rsi
callq 0x1030
xorl %r15d, %r15d
jmp 0x12a2
nop
// File: /workspace/github_cpp_makefile_star2_O2/lhartmann[P]orangepi-i2s-steppers/./throttle.h
// Function: Throttle::step()
bool step() {
        if (paused) {
            // On pause, decelerate gracefully to zero.
            if (r) r--;
        } else {
            // If before brake point
            if (n<n1) {
                // Then accelerate to max-speed
                if (r < rd) r++;
            } else {
                // Otherwise decelerate to end-speed
                if (r > r1) r--;

                // On resume, accelerate to end-speed
                if (r < r1) r++;
            }
        }
        acc += r;
        if (acc > 0) {
            acc -= rd;
            if (n < N) n++;
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x20(%rdi)
jne 0x12e7
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0x131e
decl %eax
jmp 0x1319
movl (%rdi), %ecx
movl 0x18(%rdi), %eax
cmpl 0x4(%rdi), %ecx
jae 0x12fa
cmpl 0xc(%rdi), %eax
jae 0x1320
incl %eax
jmp 0x1319
movl 0x14(%rdi), %ecx
xorl %edx, %edx
cmpl %ecx, %eax
seta %dl
subl %edx, %eax
xorl %esi, %esi
cmpl %ecx, %eax
setb %sil
addl %esi, %eax
orb %dl, %sil
cmpb $0x1, %sil
jne 0x1320
movl %eax, 0x18(%rdi)
jmp 0x1320
xorl %eax, %eax
addl 0x1c(%rdi), %eax
movl %eax, 0x1c(%rdi)
testl %eax, %eax
jle 0x133d
movl %eax, %ecx
subl 0xc(%rdi), %ecx
movl %ecx, 0x1c(%rdi)
movl (%rdi), %ecx
cmpl 0x8(%rdi), %ecx
jae 0x133d
incl %ecx
movl %ecx, (%rdi)
testl %eax, %eax
setg %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lhartmann[P]orangepi-i2s-steppers/./stepper.h
// Function: Stepper::step()
bool step() {
        acc += rate_up;
        if (acc>0) {
            acc -= rate_dn;
            if (++current == end) {
                prepare (0,0);
            }
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rdi), %eax
addl 0x8(%rdi), %eax
movl %eax, 0x10(%rdi)
testl %eax, %eax
jle 0x1372
movl %eax, %ecx
subl 0xc(%rdi), %ecx
movl %ecx, 0x10(%rdi)
movl (%rdi), %ecx
incl %ecx
movl %ecx, (%rdi)
cmpl 0x4(%rdi), %ecx
jne 0x1372
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andl $0x0, 0x10(%rdi)
testl %eax, %eax
setg %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lhartmann[P]orangepi-i2s-steppers/./maskedtransportdelay.h
// Function: MaskedTransportDelay<unsigned int, 1, 2147483647u>::operator()(unsigned int)
T operator() (T x) {
        // Advance pointer
        if (p == buff) p += N-1;
        else p--;

        // Exchange data
        T y = *p;
        *p = x;

        return y & M | x & ~M;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movq 0x8(%rdi), %rcx
cmpq %rdi, %rcx
je 0x1391
addq $-0x4, %rcx
movq %rcx, 0x8(%rdi)
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl (%rcx), %edx
movl %eax, (%rcx)
andl $0x80000000, %eax       # imm = 0x80000000
orl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/background_grid.cpp
// Function: load_grid()
void load_grid()
{
	int iy,ix;

	ifstream infile;
	infile.open(GRID_FILE);

	for(ix=1; ix < NPOINT+1; ix++)
		infile >> gpoint[ix].x >> gpoint[ix].y;

	for(ix=1; ix < NCELL+1; ix++)
		for(iy=0; iy<4; iy++) 
			infile >> gcell[ix].pn[iy];
        
	//for(iy=1; iy<=Ny4grd+2; iy++)
	for(iy=1; iy<=Ny; iy++)
	{
	//	for(ix=1; ix<=Nx4grd+2; ix++)
	for(ix=1; ix<=Nx; ix++)
		{
			//bgrid[iy-1][ix-1]=gcell[(ix-1)*(Ny4grd+2)+Ny4grd+2-(iy-1)];
			bgrid[iy-1][ix-1]=gcell[(ix-1)*Ny+Ny-(iy-1)];
		}
	}
	infile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3210
leaq 0x16dc8(%rip), %rsi     # 0x1b088
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3120
pushq $0x18
popq %r14
movq %rsp, %rbx
cmpq $0x150618, %r14         # imm = 0x150618
je 0x430a
movq 0x1efbe(%rip), %rax     # 0x232a0
leaq (%rax,%r14), %rsi
addq $-0x8, %rsi
movq %rbx, %rdi
callq 0x3130
movq 0x1efa7(%rip), %rsi     # 0x232a0
addq %r14, %rsi
movq %rax, %rdi
callq 0x3130
addq $0x10, %r14
jmp 0x42d2
pushq $0x1
popq %r14
pushq $0x10
popq %r15
movq %rsp, %rbx
cmpq $0x14e17, %r14          # imm = 0x14E17
je 0x434b
xorl %r12d, %r12d
cmpq $0x10, %r12
je 0x4342
movq 0x1ef7a(%rip), %rsi     # 0x232a8
addq %r15, %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x3110
addq $0x4, %r12
jmp 0x4321
incq %r14
addq $0x10, %r15
jmp 0x4315
movq 0x1ef46(%rip), %rax     # 0x23298
movl $0x410, %ecx            # imm = 0x410
addq 0x1ef4a(%rip), %rcx     # 0x232a8
pushq $0x1
popq %rdx
cmpq $0x42, %rdx
je 0x4398
movq %rcx, %rsi
xorl %edi, %edi
cmpq $0x7b0, %rdi            # imm = 0x7B0
je 0x4389
movups (%rsi), %xmm0
movups %xmm0, (%rax,%rdi)
addq $0x10, %rdi
addq $0x410, %rsi            # imm = 0x410
jmp 0x436c
incq %rdx
addq $-0x10, %rcx
addq $0x7b0, %rax            # imm = 0x7B0
jmp 0x4361
movq %rsp, %rdi
callq 0x3060
movq %rsp, %rdi
callq 0x3080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x43bb
jmp 0x43bb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: bodygridclass::set_invM()
void set_invM() {
        invM[0]=1.0/dx/dy;   
        invM[1]=3.0/dx/dy;
        invM[2]=3.0/dx/dy;
        invM[3]=9.0/dx/dy;
        invM[4]=45.0/4.0/dx/dy;
        invM[5]=45.0/4.0/dx/dy;
    }

// Assembly:
movupd 0x288(%rdi), %xmm0
movupd 0x290(%rdi), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x16c66(%rip), %xmm2    # 0x1b050
divpd %xmm0, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
movhpd %xmm2, 0x10(%rdi)
movapd 0x16c59(%rip), %xmm2    # 0x1b060
divpd %xmm0, %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x18(%rdi)
movhpd %xmm2, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/bodygridclass.cpp
// Function: bodygridclass::bodygridclass()
bodygridclass::bodygridclass()
{
    //   pmvx=NULL;
    //   pmvy=NULL;

    flag=0;
    exflag=-1;
    level=0;//�������ڵĲ��� 
    reflag=0;//�Ƿ�����;0-δ����,1-�Ѽ���
    coflag=false;//�ж������Ƿ��ֻ���0-δ�ֻ�,1-�Ѵֻ�
    NOparent=0u;//��ʼ����������
    NOchildren=0;//��������Ԫ���������еı���
    parent=NULL; 
    bAvg=false;
    tcur=0.0; 
    tdiv=0.0;
    pio=0.0;
    trb=false;
    trbamr=false;
    kxq=kxrcf=0.0;
    maxqp=inlen=0.0;
    mvflg=false;
    vorM=0.0;
    //	struct bodygrid *children[4];

//    p_node=NULL;
    for(int m=0; m<4; ++m)  children[m]=NULL;

    for(int i=0; i<4; i++) { 
        for(int j=0; j<6; j++){
#ifdef RES_SMOOTH
            resd0[i][j]=resd1[i][j]=0.0;
#endif
            residual[i][j]=dof[i][j]=dof0[i][j]=0.0;
        }
    }
}

// Assembly:
movl $0xffff0000, 0x1b0(%rdi) # imm = 0xFFFF0000
andw $0x0, 0x1f8(%rdi)
andw $0x0, 0x1fc(%rdi)
xorl %eax, %eax
movb %al, 0x1fe(%rdi)
andl $0x0, 0x200(%rdi)
andw $0x0, 0x204(%rdi)
movb %al, 0x206(%rdi)
andw $0x0, 0x210(%rdi)
movb %al, 0x1b4(%rdi)
andq $0x0, 0x208(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x218(%rdi)
movups %xmm0, 0x228(%rdi)
movups %xmm0, 0x238(%rdi)
movups %xmm0, 0x248(%rdi)
cmpq $0x4, %rax
je 0x44ae
andq $0x0, 0x258(%rdi,%rax,8)
incq %rax
jmp 0x449a
addq $0x30, %rdi
xorl %eax, %eax
cmpq $0x4, %rax
je 0x44e7
xorl %ecx, %ecx
cmpq $0x6, %rcx
je 0x44de
andq $0x0, 0xc0(%rdi,%rcx,8)
andq $0x0, (%rdi,%rcx,8)
andq $0x0, 0x270(%rdi,%rcx,8)
incq %rcx
jmp 0x44bc
incq %rax
addq $0x30, %rdi
jmp 0x44b4
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/bodygridclass.cpp
// Function: Face::Face()
Face::Face()
{
    parent=NULL; //left cell
    neighbor=NULL; //right cell
    //parent is the id of the cell owning this face
    // A cell owns a face if the face normal is pointing outwards from it
    // The other cell is called the neighbor
    //  Vec2D nml;
    nml[0]=0.0;
    nml[1]=0.0; 

    bHang=false;
    for(int ii=0; ii<3; ++ii){
        gs_pt[ii][0]=gs_pt[ii][1]=0.0;
        for(int jj=0; jj<4; ++jj)
            faceflux[ii][jj]=0.0; //face flux at 3 gauss points
    }         
    area=0.0; //the area of the face in 3d or lenth in 2d
}

// Assembly:
movb $0x0, 0xb8(%rdi)
leaq 0x20(%rdi), %rax
leaq 0x50(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x45eb
movq %rdx, %rsi
shlq $0x4, %rsi
movups %xmm0, (%rax,%rsi)
xorl %esi, %esi
cmpq $0x4, %rsi
je 0x45e2
andq $0x0, (%rcx,%rsi,8)
incq %rsi
jmp 0x45d2
incq %rdx
addq $0x20, %rcx
jmp 0x45bf
andq $0x0, 0xb0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: bodygridclass::set_invM(double, double)
void set_invM(double dsx, double dsy) {
        invM[0]=1.0/dsx/dsy;   
        invM[1]=3.0/dsx/dsy;
        invM[2]=3.0/dsx/dsy;
        invM[3]=9.0/dsx/dsy;
        invM[4]=45.0/4.0/dsx/dsy;
        invM[5]=45.0/4.0/dsx/dsy;
    }

// Assembly:
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x16a02(%rip), %xmm2    # 0x1b050
divpd %xmm0, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
movhpd %xmm2, 0x10(%rdi)
movapd 0x169f5(%rip), %xmm2    # 0x1b060
divpd %xmm0, %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x18(%rdi)
movhpd %xmm2, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: Vec3D::cross(Vec3D const&)
Vec3D Vec3D::cross(const Vec3D &right) {
	Vec3D temp;
	temp.comp[0]=comp[1]*right.comp[2]-comp[2]*right.comp[1];
	temp.comp[1]=-comp[0]*right.comp[2]+comp[2]*right.comp[0];
	temp.comp[2]=comp[0]*right.comp[1]-comp[1]*right.comp[0];
	return temp;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movapd 0x169ac(%rip), %xmm2    # 0x1b0a0
movsd 0x10(%rsi), %xmm3
movapd %xmm3, %xmm4
xorpd %xmm2, %xmm4
xorpd %xmm0, %xmm2
movupd (%rdx), %xmm5
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm5, %xmm3
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
movsd 0x10(%rdx), %xmm4
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm2, %xmm4
addpd %xmm3, %xmm4
shufpd $0x1, %xmm4, %xmm4      # xmm4 = xmm4[1,0]
movupd %xmm4, (%rdi)
mulsd %xmm5, %xmm1
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
mulsd %xmm0, %xmm5
subsd %xmm1, %xmm5
movsd %xmm5, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: Vec3D::operator*(double const&)
Vec3D Vec3D::operator*(const double &right) {
	Vec3D temp;
	temp.comp[0]=comp[0]*right;
	temp.comp[1]=comp[1]*right;
	temp.comp[2]=comp[2]*right;
	return temp;
}

// Assembly:
movq %rdi, %rax
movsd (%rdx), %xmm0
movupd (%rsi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: operator*(double const&, Vec3D const&)
Vec3D operator*(const double &left, const Vec3D &right) {
	Vec3D temp;
	temp.comp[0]=left*right.comp[0];
	temp.comp[1]=left*right.comp[1];
	temp.comp[2]=left*right.comp[2];
	return temp;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movupd (%rdx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: operator/(double const&, Vec3D const&)
Vec3D operator/ (const double &left, const Vec3D &right) {
	Vec3D temp;
	temp.comp[0]=left/right.comp[0];
	temp.comp[1]=left/right.comp[1];
	temp.comp[2]=left/right.comp[2];
	return temp;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movupd (%rdx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
divsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: operator+(Vec3D const&, Vec3D const&)
Vec3D operator+ (const Vec3D &left, const Vec3D &right) {
	Vec3D temp;
	temp.comp[0]=left.comp[0]+right.comp[0];
	temp.comp[1]=left.comp[1]+right.comp[1];
	temp.comp[2]=left.comp[2]+right.comp[2];
	return temp;
}

// Assembly:
movq %rdi, %rax
movupd (%rsi), %xmm0
movupd (%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/setflag.cpp
// Function: set_exFlag4All(int, pointxy*)
void set_exFlag4All(int nmpnt, PXYZ wallpt[]) 
{
    Node *current;
    OctCell *lsbl;
    OctCell *lsbl1[4];
    double x1,y1;
    int value, flg=0;

    double xcn[4],ycn[4];
    int flgn[4], sflg;	

    current = HeadListAllGrid;
    while(current != NULL)
    {
        lsbl = current->cell;

        x1=lsbl->xc1;
        y1=lsbl->yc1;
        flg=0;

        value = newFlagpoint(x1,y1,nmpnt, wallpt);
        if(value==0 ) {
            flg=-1;
            lsbl->flag=-1; ///
        }
        lsbl->exflag=flg;
        current=current->next;
    }
    //cout<<"it is ok\n";

    current = HeadListAllGrid;
    while(current != NULL)
    {
        lsbl = current->cell;
        if(lsbl->exflag==-1){
            if(current->flg!=6)
            {
                //-----------------------
                lsbl1[0]=SouthNeighbor(lsbl);
                lsbl1[1]=EastNeighbor(lsbl);	
                lsbl1[2]=NorthNeighbor(lsbl);
                lsbl1[3]=WestNeighbor(lsbl);	        
                sflg=0;
                for(int i=0; i<4; ++i) {      
                    if(lsbl1[i]->exflag==0) {
                        flg=2;
                        ++sflg;
                        break;
                    }
                }  

                if(sflg==0) flg=-1;      
                lsbl->exflag=flg;
            }
        }
        current=current->next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x2367a(%rip), %r14     # 0x28610
movq (%r14), %r14
testq %r14, %r14
je 0x4fe1
movq 0x8(%r14), %r15
movsd 0x278(%r15), %xmm0
movsd 0x280(%r15), %xmm1
movl %ebp, %edi
movq %rbx, %rsi
callq 0x9c67
testl %eax, %eax
je 0x4fc6
xorl %eax, %eax
jmp 0x4fd3
orw $-0x1, 0x1b0(%r15)
movw $0xffff, %ax            # imm = 0xFFFF
movw %ax, 0x1b2(%r15)
addq $0x10, %r14
jmp 0x4f96
leaq 0x23628(%rip), %r14     # 0x28610
movq (%r14), %r14
testq %r14, %r14
je 0x5068
movq 0x8(%r14), %rbx
cmpw $-0x1, 0x1b2(%rbx)
jne 0x5062
cmpw $0x6, (%r14)
je 0x5062
movq %rbx, %rdi
callq 0x8610
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x858f
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8488
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x850c
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x4, %rax
je 0x5057
movq (%rsp,%rax,8), %rcx
incq %rax
cmpw $0x0, 0x1b2(%rcx)
jne 0x503a
movw $0x2, %ax
jmp 0x505b
movw $0xffff, %ax            # imm = 0xFFFF
movw %ax, 0x1b2(%rbx)
addq $0x10, %r14
jmp 0x4fe8
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: Vec4D::operator*(double const&)
Vec4D Vec4D::operator*(const double &right) {
	Vec4D temp;
	temp.comp[0]=comp[0]*right;
	temp.comp[1]=comp[1]*right;
	temp.comp[2]=comp[2]*right;
	temp.comp[3]=comp[3]*right;	
	return temp;
}

// Assembly:
movq %rdi, %rax
movupd (%rsi), %xmm0
movsd (%rdx), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
movupd 0x10(%rsi), %xmm0
mulpd %xmm1, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: Vec4D::operator/(double const&)
Vec4D Vec4D::operator/ (const double &right) {
	Vec4D temp;
	temp.comp[0]=comp[0]/right;
	temp.comp[1]=comp[1]/right;
	temp.comp[2]=comp[2]/right;
	temp.comp[3]=comp[3]/right;	
	
	return temp;
}

// Assembly:
movq %rdi, %rax
movupd (%rsi), %xmm0
movsd (%rdx), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
movupd 0x10(%rsi), %xmm0
divpd %xmm1, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: operator*(double const&, Vec4D const&)
Vec4D operator*(const double &left, const Vec4D &right) {
	Vec4D temp;
	temp.comp[0]=left*right.comp[0];
	temp.comp[1]=left*right.comp[1];
	temp.comp[2]=left*right.comp[2];
	temp.comp[3]=left*right.comp[3];
	return temp;
}

// Assembly:
movq %rdi, %rax
movupd (%rdx), %xmm0
movsd (%rsi), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
movupd 0x10(%rdx), %xmm0
mulpd %xmm1, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: operator+(Vec4D const&, Vec4D const&)
Vec4D operator+ (const Vec4D &left, const Vec4D &right) {
	Vec4D temp;
	temp.comp[0]=left.comp[0]+right.comp[0];
	temp.comp[1]=left.comp[1]+right.comp[1];
	temp.comp[2]=left.comp[2]+right.comp[2];
	temp.comp[3]=left.comp[3]+right.comp[3];
	return temp;
}

// Assembly:
movq %rdi, %rax
movupd (%rsi), %xmm0
movupd (%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movupd 0x10(%rsi), %xmm0
movupd 0x10(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/outputgrid.cpp
// Function: output4restart()
void output4restart()
{
    Node *current;
    int i;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    ofstream fp1;

	string  str1=str0+"restart_data";
    fp1.open(str1.c_str());
    current = HeadListAllGrid;     
    while(current != NULL)
    {       
        pcell0 = current->cell;
        for(i=0;i<4;++i) fp1<<pcell0->dof[i][0]<<"  ";
        fp1<<"\n";
        current = current->next;
    }           
    fp1.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x28(%rsp), %rdi
callq 0x3320
leaq 0x20651(%rip), %rsi     # 0x288a0
leaq 0x13159(%rip), %rdx     # 0x1b3af
leaq 0x8(%rsp), %rdi
callq 0x844d
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x3040
leaq 0x20397(%rip), %r12     # 0x28610
leaq 0x1309a(%rip), %rbx     # 0x1b31a
leaq 0x28(%rsp), %r14
leaq 0x13af1(%rip), %r15     # 0x1bd7d
movq (%r12), %r12
testq %r12, %r12
je 0x82d8
movq 0x8(%r12), %rbp
pushq $0x30
popq %r13
cmpq $0xf0, %r13
je 0x82c7
movsd (%rbp,%r13), %xmm0
movq %r14, %rdi
callq 0x32e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
addq $0x30, %r13
jmp 0x829e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31d0
addq $0x10, %r12
jmp 0x828c
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x8(%rsp), %rdi
callq 0x33b8
leaq 0x28(%rsp), %rdi
callq 0x32a0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x831e
jmp 0x8311
jmp 0x8311
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x33b8
leaq 0x28(%rsp), %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/outputgrid.cpp
// Function: read4restart()
void read4restart()
{
    Node *current;
    int i,j;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    ifstream fp1;
    fp1.open("IN//restart_data");
    current = HeadListAllGrid;     
    while(current != NULL)
    {       
        pcell0 = current->cell;
        for(i=0;i<4;++i){
            fp1>>pcell0->dof[i][0];
            pcell0->dof0[i][0]=pcell0->dof[i][0];
            for(j=1;j<nDOF;++j)
                pcell0->dof[i][j]=0.0;
        }

        current = current->next;
    }           
    fp1.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3210
leaq 0x13056(%rip), %rsi     # 0x1b3ab
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3120
leaq 0x202a9(%rip), %rax     # 0x28610
movq (%rax), %rax
testq %rax, %rax
je 0x83d8
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %r12
leaq 0x30(%r12), %r13
leaq 0xf0(%r12), %rbp
addq $0x38, %r12
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x83cd
imulq $0x30, %r15, %rbx
leaq (%rbx,%r13), %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x3130
movsd (%r14), %xmm0
movsd %xmm0, (%rbp,%rbx)
xorl %eax, %eax
cmpq $0x5, %rax
je 0x83c4
andq $0x0, (%r12,%rax,8)
incq %rax
jmp 0x83b4
incq %r15
addq $0x30, %r12
jmp 0x838c
movq 0x8(%rsp), %rax
addq $0x10, %rax
jmp 0x8367
leaq 0x10(%rsp), %rdi
callq 0x3060
leaq 0x10(%rsp), %rdi
callq 0x3080
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8400
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: NorthNeighbor(bodygridclass*)
OctCell *NorthNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) 
	{
		return(&bodygrid[NOparent+Nx]);
	}
	
	NOchildren=pp->NOchildren;
	if(NOchildren==0) return(parent->children[3]);
    if(NOchildren==1) return(parent->children[2]);
    p=NorthNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==3) return(p->children[0]);
	else if(NOchildren==2) return(p->children[1]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x84b6
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x84b9
movzwl 0x204(%rax), %ebx
cmpl $0x1, %ebx
je 0x84db
testl %ebx, %ebx
jne 0x84e4
movq 0x270(%rdi), %rax
jmp 0x850a
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1ae1a(%rip), %rcx     # 0x232e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $0x19f20, %rax          # imm = 0x19F20
jmp 0x850a
movq 0x268(%rdi), %rax
jmp 0x850a
callq 0x8488
movq %rax, %rcx
movq 0x258(%rax), %rax
testq %rax, %rax
je 0x8507
cmpw $0x3, %bx
je 0x850a
movq 0x260(%rcx), %rax
jmp 0x850a
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: WestNeighbor(bodygridclass*)
OctCell *WestNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;

	if(parent==NULL) return(&bodygrid[NOparent-1]);	

	NOchildren=pp->NOchildren;
	if(NOchildren==1) return(parent->children[0]);
    if(NOchildren==2) return(parent->children[3]);
    p=WestNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==0) return(p->children[1]);
	else if(NOchildren==3) return(p->children[2]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x853b
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x853e
movzwl 0x204(%rax), %ebx
cmpl $0x2, %ebx
je 0x8560
cmpl $0x1, %ebx
jne 0x8569
movq 0x258(%rdi), %rax
jmp 0x858d
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1ad95(%rip), %rcx     # 0x232e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $-0x360, %rax           # imm = 0xFCA0
jmp 0x858d
movq 0x270(%rdi), %rax
jmp 0x858d
callq 0x850c
cmpq $0x0, 0x258(%rax)
je 0x858d
testw %bx, %bx
je 0x8586
movq 0x268(%rax), %rax
jmp 0x858d
movq 0x260(%rax), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: EastNeighbor(bodygridclass*)
OctCell *EastNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) return(&bodygrid[NOparent+1]);	
	NOchildren=pp->NOchildren;
	if(NOchildren==0) return(parent->children[1]);
    if(NOchildren==3) return(parent->children[2]);
    p=EastNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==1) return(p->children[0]);
	else if(NOchildren==2) return(p->children[3]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x85bd
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x85c0
movzwl 0x204(%rax), %ebx
cmpl $0x3, %ebx
je 0x85df
testl %ebx, %ebx
jne 0x85e8
movq 0x260(%rdi), %rax
jmp 0x860e
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1ad13(%rip), %rcx     # 0x232e0
imulq $0x360, %rax, %rax      # imm = 0x360
addq (%rcx), %rax
addq $0x360, %rax            # imm = 0x360
jmp 0x860e
movq 0x268(%rdi), %rax
jmp 0x860e
callq 0x858f
movq %rax, %rcx
movq 0x258(%rax), %rax
testq %rax, %rax
je 0x860b
cmpw $0x1, %bx
je 0x860e
movq 0x270(%rcx), %rax
jmp 0x860e
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: SouthNeighbor(bodygridclass*)
OctCell *SouthNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) return(&bodygrid[NOparent-Nx]);	
	NOchildren=pp->NOchildren;
	if(NOchildren==3) return(parent->children[0]);
    if(NOchildren==2) return(parent->children[1]);
    p=SouthNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==0) return(p->children[3]);
	else if(NOchildren==1) return(p->children[2]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x863f
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8642
movzwl 0x204(%rax), %ebx
cmpl $0x2, %ebx
je 0x8664
cmpl $0x3, %ebx
jne 0x866d
movq 0x258(%rdi), %rax
jmp 0x8691
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1ac91(%rip), %rcx     # 0x232e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $-0x19f20, %rax         # imm = 0xFFFE60E0
jmp 0x8691
movq 0x260(%rdi), %rax
jmp 0x8691
callq 0x8610
cmpq $0x0, 0x258(%rax)
je 0x8691
testw %bx, %bx
je 0x868a
movq 0x268(%rax), %rax
jmp 0x8691
movq 0x270(%rax), %rax
popq %rbx
retq
nop