LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Mkdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Mkdir(string dirName) {
    if (!checkPathName(dirName)) {
        return;
    }
    u_arg[1] = Inode::IFDIR;
    u_FileManager->Creat();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x773c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64a2
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6454
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r14b, %r14b
je 0x6477
movl $0x4000, 0x1024(%rbx)   # imm = 0x4000
movq 0x1400(%rbx), %rdi
callq 0x4832
movq %rbx, %rdi
callq 0x6398
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x649a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Cd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Cd(string dirName) {
    if (!checkPathName(dirName)) {
        return;
    }
    u_FileManager->ChDir();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x773c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64a2
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6836
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r14b, %r14b
je 0x684f
movq 0x1400(%rbx), %rdi
callq 0x4da2
movq %rbx, %rdi
callq 0x6398
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6872
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Create(string fileName, string mode) {
    if (!checkPathName(fileName)) {
        return;
    }
    int md = INodeMode(mode);
    if (md == 0) {
        cout << "this mode is undefined !  \n";
        return;
    }

    u_arg[1] = md;
    u_FileManager->Creat();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x773c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64a2
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x68d4
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r15b, %r15b
je 0x6951
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x773c
movq %r15, %rsi
callq 0x697e
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6917
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3220
testl %r14d, %r14d
je 0x6939
movl %r14d, 0x1024(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x4832
movq %rbx, %rdi
callq 0x6398
jmp 0x6951
movq 0x6688(%rip), %rdi      # 0xcfc8
leaq 0x2767(%rip), %rsi      # 0x90ae
movl $0x1b, %edx
callq 0x3260
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6976
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::INodeMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int User::INodeMode(string mode) {
    int md = 0;
    if (mode.find("-r") != string::npos) {
        md |= Inode::IREAD;
    }
    if (mode.find("-w") != string::npos) {
        md |= Inode::IWRITE;
    }
    if (mode.find("-rw") != string::npos) {
        md |= (Inode::IREAD | Inode::IWRITE);
    }
    return md;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x2820(%rip), %rsi      # 0x91b2
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
xorl %r14d, %r14d
cmpq $-0x1, %rax
setne %r14b
shll $0x8, %r14d
leaq 0x27fe(%rip), %rsi      # 0x91b5
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
leal 0x80(%r14), %r15d
cmpq $-0x1, %rax
cmovel %r14d, %r15d
leaq 0x27dc(%rip), %rsi      # 0x91b8
movl $0x3, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
cmpq $-0x1, %rax
movl $0x180, %eax            # imm = 0x180
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Delete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Delete(string fileName) {
    if (!checkPathName(fileName)) {
        return;
    }
    u_FileManager->UnLink();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x773c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64a2
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6a58
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r14b, %r14b
je 0x6a71
movq 0x1400(%rbx), %rdi
callq 0x49ee
movq %rbx, %rdi
callq 0x6398
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6a94
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Open(string fileName, string mode) {
    if (!checkPathName(fileName)) {
        return;
    }
    int md = FileMode(mode);
    if (md == 0) {
        cout << "Open����������\n";
        return;
    }

    u_arg[1] = md;
    u_FileManager->Open();
    if (IsError())
        return;
    cout << "�����ļ��ɹ������صľ���fd�ǣ�" << u_ar0[EAX] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x773c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64a2
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6af6
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r15b, %r15b
je 0x6bcb
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x773c
movq %r15, %rsi
callq 0x6bf8
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6b3d
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3220
testl %r14d, %r14d
je 0x6bb3
movl %r14d, 0x1024(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x4464
movq %rbx, %rdi
callq 0x6398
testb %al, %al
jne 0x6bcb
movq 0x6460(%rip), %r14      # 0xcfc8
leaq 0x256b(%rip), %rsi      # 0x90da
movl $0x1e, %edx
movq %r14, %rdi
callq 0x3260
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x3160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
jmp 0x6bcb
movq 0x640e(%rip), %rdi      # 0xcfc8
leaq 0x2509(%rip), %rsi      # 0x90ca
movl $0xf, %edx
callq 0x3260
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6bf0
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::FileMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int User::FileMode(string mode) {
    int md = 0;
    if (mode.find("-r") != string::npos) {
        md |= File::FREAD;
    }
    if (mode.find("-w") != string::npos) {
        md |= File::FWRITE;
    }
    if (mode.find("-rw") != string::npos) {
        md |= (File::FREAD | File::FWRITE);
    }
    return md;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x25a6(%rip), %rsi      # 0x91b2
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
xorl %r14d, %r14d
cmpq $-0x1, %rax
setne %r14b
leaq 0x2588(%rip), %rsi      # 0x91b5
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
leal 0x2(%r14), %r15d
cmpq $-0x1, %rax
cmovel %r14d, %r15d
leaq 0x2569(%rip), %rsi      # 0x91b8
movl $0x3, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
cmpq $-0x1, %rax
movl $0x3, %eax
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Close(string sfd) {
    if (sfd.empty() || !isdigit(sfd.front())) {
        cout << "Close����������\n";
        return;
    }
    u_arg[0] = stoi(sfd);;
    u_FileManager->Close();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rsi)
je 0x6d07
movq (%rsi), %r15
movsbl (%r15), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x6d07
movq %rdi, %r14
callq 0x3050
movq %rax, %rbx
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x3310
cmpq %r15, (%r12)
je 0x6d2d
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6d39
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x6d39
testl %ecx, %ecx
jne 0x6cde
movl %r13d, (%rbx)
movl %eax, 0x1020(%r14)
movq 0x1400(%r14), %rdi
callq 0x4984
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6398
movq 0x62ba(%rip), %rdi      # 0xcfc8
leaq 0x23e4(%rip), %rsi      # 0x90f9
movl $0x10, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3260
leaq 0x2583(%rip), %rdi      # 0x92b7
callq 0x3150
leaq 0x2577(%rip), %rdi      # 0x92b7
callq 0x3320
cmpl $0x0, (%rbx)
jne 0x6d4d
movl %r13d, (%rbx)
movq %rax, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::EchoError(User::ErrorCode)
void User::EchoError(enum ErrorCode err) {
    string estr;
    switch (err) {
        case User::myNOERROR:
            estr = " No u_error ";
            break;
        case User::myENOENT:
            estr = " No such file or directory ";
            break;
        case User::myEBADF:
            estr = " Bad file number ";
            break;
        case User::myEACCES:
            estr = " Permission denied ";
            break;
        case User::myENOTDIR:
            estr = " Not a directory ";
            break;
        case User::myENFILE:
            estr = " File table overflow ";
            break;
        case User::myEMFILE:
            estr = " Too many open files ";
            break;
        case User::myEFBIG:
            estr = " File too large ";
            break;
        case User::myENOSPC:
            estr = " No space left on device ";
            break;
        default:
            break;
    }
    cout << estr << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpl $0xc, %esi
jle 0x7626
leal -0x14(%rsi), %eax
cmpl $0x8, %eax
ja 0x7665
leaq 0x1a7d(%rip), %rcx      # 0x9088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x11, %r8d
leaq 0x1c2d(%rip), %rcx      # 0x924e
jmp 0x76b3
testl %esi, %esi
je 0x7647
cmpl $0x2, %esi
je 0x7656
cmpl $0x9, %esi
jne 0x76c0
movl $0x11, %r8d
leaq 0x1be3(%rip), %rcx      # 0x9228
jmp 0x76b3
movl $0xc, %r8d
leaq 0x1bab(%rip), %rcx      # 0x91ff
jmp 0x76b3
movl $0x1b, %r8d
leaq 0x1ba9(%rip), %rcx      # 0x920c
jmp 0x76b3
cmpl $0xd, %esi
jne 0x76c0
movl $0x13, %r8d
leaq 0x1bc3(%rip), %rcx      # 0x923a
jmp 0x76b3
movl $0x15, %r8d
leaq 0x1bf0(%rip), %rcx      # 0x9276
jmp 0x76b3
movl $0x15, %r8d
leaq 0x1bcb(%rip), %rcx      # 0x9260
jmp 0x76b3
movl $0x19, %r8d
leaq 0x1bf9(%rip), %rcx      # 0x929d
jmp 0x76b3
movl $0x10, %r8d
leaq 0x1bd9(%rip), %rcx      # 0x928c
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3370
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x58f9(%rip), %rdi      # 0xcfc8
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x7713
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3220
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x7734
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/common.cpp
// Function: getCmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> getCmd(string str)
{
	vector<string> result;
	result.clear();

	stringstream cmd(str); // ��str��Ϊ������
	string tempResult;
	while (cmd >> tempResult) {
		result.push_back(tempResult);
	}

	if (DEBUG) {
		cout << "����������������Ϊ" << endl;
		for (int cnt = 0; cnt < result.size(); cnt++) {
			cout << result[cnt] << ' ';
		}
		cout << endl;
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x84ee
leaq -0x1d8(%rbp), %rdi
movq %r14, %rsi
movl $0x18, %edx
callq 0x3390
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x1d8(%rbp), %r14
leaq -0x50(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7867
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8434
jmp 0x7841
leaq 0x59e3(%rip), %rax      # 0xd251
cmpb $0x1, (%rax)
jne 0x794c
movq 0x574a(%rip), %r14      # 0xcfc8
leaq 0x1aac(%rip), %rsi      # 0x9331
movl $0x12, %edx
movq %r14, %rdi
callq 0x3260
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq 0x5718(%rip), %rdi      # 0xcfc8
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x7919
movl $0x8, %r13d
xorl %r14d, %r14d
movq 0x56f2(%rip), %r15      # 0xcfc8
leaq -0x29(%rbp), %r12
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x3260
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3260
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %r14, %rcx
ja 0x78da
movq 0x56a8(%rip), %rdi      # 0xcfc8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
leaq -0x40(%rbp), %r12
callq 0x31f0
movsbl %al, %esi
movq 0x5689(%rip), %rdi      # 0xcfc8
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x7961
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3220
movq 0x5640(%rip), %rsi      # 0xcfa8
leaq -0x1d8(%rbp), %rdi
callq 0x3190
leaq -0x158(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x79dc
jmp 0x79a5
movq %rax, %r14
leaq -0x40(%rbp), %r12
jmp 0x79a8
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x79bd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3220
movq 0x55e4(%rip), %rsi      # 0xcfa8
leaq -0x1d8(%rbp), %rdi
callq 0x3190
leaq -0x158(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x8480
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/main.cpp
// Function: main
int main()
{
	DEBUG = false;


	while (1) {
		cout << "[u1851977@localhost " + globalUser.u_curdir + "]$ ";
		getline(cin, line);

		vector<string> cmdList = getCmd(line); // ��ʱ��һ����Ϊ������

		exeCmd(cmdList);

	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movb $0x0, 0x4a35(%rip)      # 0xd251
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %r13
leaq -0xa0(%rbp), %r14
leaq -0x88(%rbp), %r12
movq %r12, %rdi
leaq 0xb91(%rip), %rsi       # 0x93cd
leaq 0x1643d(%rip), %rdx     # 0x1ec80
callq 0x89ec
movq %r12, %rdi
leaq 0xb90(%rip), %rsi       # 0x93e2
callq 0x3410
movq %r15, -0x48(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8877
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x887e
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x4724(%rip), %rdi      # 0xcfc8
callq 0x3260
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x88be
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
movq %r15, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x88dd
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3220
movq 0x46fc(%rip), %r15      # 0xcfe0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %edx
movq %r15, %rdi
leaq 0x166fb(%rip), %rsi     # 0x1f000
callq 0x3400
leaq -0x58(%rbp), %r12
movq %r12, -0x68(%rbp)
movq 0x166e7(%rip), %rsi     # 0x1f000
movq 0x166e8(%rip), %rdx     # 0x1f008
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x773c
movq %r13, %rdi
movq %r15, %rsi
callq 0x77dc
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x894f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3220
movq %r14, %rdi
movq %r13, %rsi
callq 0x8a7e
movq %rbx, %r15
movq %r14, %rdi
callq 0x79ec
movq %r14, %rdi
callq 0x8480
movq %r13, %rdi
callq 0x8480
jmp 0x882b
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x8480
jmp 0x898e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x8480
jmp 0x89e4
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x89e4
movq -0x58(%rbp), %rsi
jmp 0x89dc
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x89c8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
jmp 0x89c8
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x89e4
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: SpaceDebug(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SpaceDebug(std::string getData)
{
    // A 2-pointer approach to remove spaces from both ends inside a tag.
    long long int ptr1 = 0, ptr2 = getData.length() - 1;
    while (getData[ptr1] == ' ' || getData[ptr2] == ' ')
    {
        if (getData[ptr1] == ' ')
            ptr1++;
        if (getData[ptr2] == ' ')
            ptr2--;
    }
    return getData.substr(ptr1, ptr2 - ptr1 + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
decq %rcx
xorl %edx, %edx
movb (%rax,%rdx), %dil
movb (%rax,%rcx), %r9b
cmpb $0x20, %dil
jne 0x4069
xorl %r8d, %r8d
cmpb $0x20, %r9b
sete %r8b
negq %r8
jmp 0x4076
movq $-0x1, %r8
cmpb $0x20, %r9b
jne 0x4089
xorl %r9d, %r9d
cmpb $0x20, %dil
sete %r9b
addq %r9, %rdx
addq %r8, %rcx
jmp 0x404b
subq %rdx, %rcx
incq %rcx
movq %rbx, %rdi
callq 0x21a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: arrangeDebugger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string arrangeDebugger(std::string getData)
{
    std::string newGetData = "";
    for (int i = 0; i < getData.length(); i++)
    {
        if (getData[i] == '=' || getData[i] == ',')
        {
            newGetData += ' ';
            newGetData += getData[i];
            newGetData += ' ';
        }
        else
        {
            newGetData += getData[i];
        }
    }
    return newGetData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x3fe1(%rip), %rdx      # 0x80a4
movq %rdx, %rsi
callq 0x7770
cmpq $0x0, 0x8(%r14)
je 0x411e
xorl %r12d, %r12d
movq (%r14), %rax
movzbl (%rax,%r12), %r13d
cmpl $0x3d, %r13d
je 0x40e9
cmpl $0x2c, %r13d
jne 0x4109
movq %rbx, %rdi
movl $0x20, %esi
callq 0x2140
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movb $0x20, %r13b
movq %rbx, %rdi
callq 0x2140
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x2140
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x40d5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4146
movq (%r15), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Cache<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::less<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, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>>>, lru::NullLock>::insert(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&)
void insert(const Key& key, const Value& value) {
		ScopedLock scoped(m_lock);
		typename MapType::iterator iter = m_cache.find(key);
		if (iter != m_cache.end()) {
			iter->second->value = value;
			m_keys.remove(iter->second);
			m_keys.push(iter->second);
		} else {
			Node<Key, Value>* n = new Node<Key, Value>(key, value);
			m_cache[key] = n;
			m_keys.push(n);
			prune();
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rax
movq %rdi, -0x30(%rbp)
callq *0x10(%rax)
leaq 0x10(%r14), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2e0a
movq %rax, %rbx
leaq 0x18(%r14), %rax
cmpq %rax, %rbx
je 0x27d1
movq 0x40(%rbx), %rdi
addq $0x38, %rdi
movq %r15, %rsi
callq 0x2090
addq $0x40, %r14
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2bcc
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2c12
jmp 0x280e
movl $0x58, %edi
callq 0x2120
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2c6e
movq %r13, %rdi
movq %r12, %rsi
callq 0x2cf4
movq %rbx, (%rax)
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x2c12
movq %r14, %rdi
callq 0x2d74
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %rbx
movl $0x58, %esi
callq 0x2130
jmp 0x2840
jmp 0x2852
jmp 0x283d
movq %rax, %rbx
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2a77
// File: /workspace/github_cpp_makefile_star2_O3/mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Cache<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::less<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, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>>>, lru::NullLock>::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Value& get(const Key& key) {
		ScopedLock scoped(m_lock);
		typename MapType::iterator iter = m_cache.find(key);
		if (iter == m_cache.end()) {
			throw KeyNotFound();
		}
		m_keys.remove(iter->second);
		m_keys.push(iter->second);
		return iter->second->value;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2e0a
movq %rax, %r15
leaq 0x18(%r14), %rax
cmpq %rax, %r15
je 0x29dd
addq $0x40, %r14
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x2bcc
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x2c12
movq 0x40(%r15), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x38, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x2080
leaq 0x43aa(%rip), %rcx      # 0x6d98
movq %rcx, (%rax)
leaq 0x4378(%rip), %rsi      # 0x6d70
movq 0x45e1(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x21a0
jmp 0x2a1d
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2a77
nop
// File: /workspace/github_cpp_makefile_star2_O3/mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove(lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
Node<Key, Value>* remove(Node<Key, Value>* node) {
		if (node == head) {
			head = node->next;
		}
		if (node == tail) {
			tail = node->prev;
		}
		node->unlink();
		size--;
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
cmpq %rsi, 0x8(%rdi)
jne 0x2be1
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rax), %rcx
cmpq %rax, 0x10(%rdi)
jne 0x2bef
movq %rcx, 0x10(%rdi)
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x2bfc
movq %rcx, 0x8(%rdx)
testq %rcx, %rcx
je 0x2c05
movq %rdx, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
decq 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::push(lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void push(Node<Key, Value>* node) {
		node->unlink();
		if (!head) {
			head = node;
		} else if (head == tail) {
			head->next = node;
			node->prev = head;
		} else {
			tail->next = node;
			node->prev = tail;
		}
		tail = node;
		size++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x2c27
movq %rax, 0x8(%rcx)
leaq 0x8(%rsi), %rdx
testq %rax, %rax
je 0x2c34
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2c56
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x2c5c
movq %rsi, 0x10(%rcx)
movq %rcx, 0x8(%rsi)
jmp 0x2c64
movq %rsi, 0x8(%rdi)
jmp 0x2c64
movq %rsi, 0x10(%rax)
movq %rax, 0x8(%rsi)
movq %rsi, 0x10(%rdi)
incq 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::Cache<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::less<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, lru::Node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*>>>, lru::NullLock>::prune()
size_t prune() {
		if (m_maxSize > 0 && m_cache.size() >= (m_maxSize + m_elasticity)) {
			size_t count = 0;
			while (m_cache.size() > m_maxSize) {
				Node<Key, Value>* n = m_keys.pop();
				m_cache.erase(n->key);
				delete n;
				count++;
			}
			return count;
		} else {
			return 0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x2df4
movq %rdi, %rbx
movq 0x38(%rdi), %rcx
movq 0x68(%rdi), %rdx
addq %rax, %rdx
cmpq %rdx, %rcx
setb %dl
cmpq %rax, %rcx
setbe %al
orb %dl, %al
jne 0x2df4
leaq 0x10(%rbx), %r15
leaq 0x40(%rbx), %r12
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x32ee
movq %rax, %r13
leaq 0x18(%rax), %rsi
movq %r15, %rdi
callq 0x333a
movq %r15, %rdi
movq %rax, %rsi
callq 0x33f6
testq %r13, %r13
je 0x2de5
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
incq %r14
movq 0x38(%rbx), %rax
cmpq 0x60(%rbx), %rax
ja 0x2db4
jmp 0x2df7
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mohaps[P]lrucache/./LRUCache.hpp
// Function: lru::List<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pop()
Node<Key, Value>* pop() {
		if (!head) {
			return 0;
		} else {
			Node<Key, Value>* newHead = head->next;
			head->unlink();
			Node<Key, Value>* oldHead = head;
			head = newHead;
			size--;
			if (size == 0) {
				tail = 0;
			}
			return oldHead;
		}
	}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x3337
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x330c
movq %rdx, 0x8(%rcx)
addq $0x8, %rax
testq %rdx, %rdx
je 0x3319
movq %rcx, 0x10(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x8(%rdi), %rax
movq %rcx, 0x8(%rdi)
decq 0x18(%rdi)
jne 0x3335
movq $0x0, 0x10(%rdi)
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: canonify_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string
canonify_filename(string filename)
{
 size_t pos = 0;

 // remove double slashes
 if ((pos = filename.find("//", 0)) < filename.size())
  filename.replace(pos, 2, "/");

 if (filename[0] != '~')
  return filename;

 // resolve home directory
 return string(getenv("HOME")) + filename.substr(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6624(%rip), %rsi      # 0xa034
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3610
cmpq 0x8(%r14), %rax
jae 0x3a42
leaq 0x6609(%rip), %rcx      # 0xa035
movl $0x2, %edx
movl $0x1, %r8d
movq %r14, %rdi
movq %rax, %rsi
callq 0x33b0
movq (%r14), %rcx
cmpb $0x7e, (%rcx)
jne 0x3ad9
leaq 0x65e2(%rip), %rdi      # 0xa037
callq 0x3420
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x4900
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3370
leaq 0x38(%rsp), %r14
movq -0x10(%r14), %rcx
movq -0x8(%r14), %r8
movq 0x10(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x3aaa
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x3acd
leaq 0x18(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x3ac8
movq 0x18(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x3b18
leaq 0x28(%rsp), %rdi
callq 0x3110
jmp 0x3b26
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
leaq 0x10(%r14), %rax
cmpq %rax, %rcx
je 0x3af5
movq %rcx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x3afb
movups (%rax), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
jmp 0x3b99
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33b0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x3b45
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3b4b
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b82
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x3b99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bc7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
jmp 0x3bc7
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3be2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: xmalloc(unsigned long)
void *
xmalloc(size_t n)
{
 void * p = malloc(n);
 if (!p && n != 0) {
  fprintf(stderr, "memory exhausted\n");
  abort();
 }

 return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3480
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x400b
popq %rbx
retq
callq 0x36c0
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: get_cwd_as_charp()
char *
get_cwd_as_charp(void)
{
 char * buf;
 char * result = NULL;
 size_t size = (size_t)pathconf(".", _PC_PATH_MAX);

 buf = (char *)xmalloc(size);
 result = getcwd(buf, size);
 if (result == NULL) {
  message("cannot determine current working directory.exit.");
  sleep(1);
  abort_xs();
 }

 result = strdup(buf);
 free(buf);

 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6172(%rip), %rdi      # 0xa1b1
movl $0x4, %esi
callq 0x3590
movq %rax, %r14
movq %rax, %rdi
callq 0x3ff0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x31c0
testq %rax, %rax
je 0x4085
movq %rbx, %rdi
callq 0x3650
movq %rax, %r14
movq %rbx, %rdi
callq 0x3400
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5fca(%rip), %rdi      # 0xa056
callq 0x9214
movl $0x1, %edi
callq 0x3280
callq 0x4010
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: get_cwd_as_string[abi:cxx11]()
string
get_cwd_as_string(void)
{
 char * cwd = get_cwd_as_charp();
 if (cwd == NULL)
  return "";
 else {
  string result = string(cwd);
  free(cwd);
  return result;
 }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4034
movq %rax, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
testq %r14, %r14
je 0x40de
movq %r14, %rdi
callq 0x3180
movq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b0e
movq %r14, %rdi
callq 0x3400
jmp 0x40f0
leaq 0x62ae(%rip), %rdx      # 0xa393
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4b0e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, pathtype)
bool
valid(string path, pathtype mode)
{
 struct stat buf;
 string canon_path = canonify_filename(path);

 if(mode == PATH_IS_FILE) {
  stat(canon_path.c_str(), &buf);
  if (S_ISREG(buf.st_mode))
   return true;
 } else if (mode == PATH_IS_DIR) {
  stat(canon_path.c_str(), &buf);
  if (S_ISDIR(buf.st_mode))
   return true;
 }

 return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4a20
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x39fc
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x414a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
cmpl $0x1, %ebx
je 0x41a2
testl %ebx, %ebx
jne 0x4176
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x3310
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
movb $0x1, %bl
cmpl $0x8000, %eax           # imm = 0x8000
je 0x4178
xorl %ebx, %ebx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4193
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x3310
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rbx), %eax
movb $0x1, %bl
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4176
jmp 0x4178
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x41e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: finish(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void
finish(string result, bool retval)
{
 curs_set(1); // re-show cursor (FIXME: necessary?)
 clear();
 refresh();   // ..and make sure we really see the clean screen
 //resetty();   // ??
 endwin();    // finish the curses at all

 // only save if list was not filtered!
 if (!NeedleGiven)
  list_to_file();

 // is the result really a dir?
 if (!valid(result, PATH_IS_DIR)) {
  fprintf(stderr, "This is not a valid directory:\n%s\n", result.c_str());
  exit(-3);
 }

 string resfile = canonify_filename(string(DefaultResultfile));
 ofstream out(resfile.c_str());
 if (out) {
  out << result << endl;
  out.close();
 }

 if (!retval)
  exit(1);

 exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x32a0
callq 0x3600
callq 0x35f0
callq 0x33e0
cmpb $0x0, 0xa294(%rip)      # 0xe4b0
jne 0x4223
callq 0x5cd3
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4a20
movq %r15, %rdi
movl $0x1, %esi
callq 0x40fb
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x426a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
testb %bpl, %bpl
je 0x4304
movq 0xa0fe(%rip), %rsi      # 0xe378
movq %rsp, %rdi
leaq 0x60(%rsp), %rdx
callq 0x4900
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x39fc
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3350
movq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movl $0x10, %edx
callq 0x33a0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x42f9
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x60(%rsp), %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x31b0
leaq 0x60(%rsp), %rdi
callq 0x34b0
testb %bl, %bl
je 0x4329
xorl %edi, %edi
callq 0x3410
movq 0x9cbd(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0x5d6f(%rip), %rsi      # 0xa087
xorl %eax, %eax
callq 0x34c0
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x3410
movl $0x1, %edi
callq 0x3410
movq %rax, %rbx
movq 0x9c7b(%rip), %rax      # 0xdfb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x68(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x60(%rsp,%rcx)
callq 0x32c0
leaq 0x158(%rsp), %rdi
callq 0x3130
jmp 0x436d
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43b9
movq 0x50(%rsp), %rsi
jmp 0x43b1
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43b9
movq 0x10(%rsp), %rsi
jmp 0x43b1
movq %rax, %rbx
jmp 0x43b9
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x43b9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: terminate(int)
void
terminate(int signo)
{
 endwin();

 if (signo == 11) {
  fprintf(stderr, "program received signal %d\n", signo);
  fprintf(stderr, "This should never happen.\n");
  fprintf(stderr, "Maybe you want to send an email to the author and report a bug?\n");
  fprintf(stderr, "Author: Linkerist <Linkerist@163.com>\n"); 
 }

 fprintf(stderr, "abort.\n");
 exit(1);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x33e0
cmpl $0xb, %ebx
jne 0x4458
movq 0x9bd1(%rip), %rbx      # 0xdfc8
movq (%rbx), %rdi
leaq 0x5ca9(%rip), %rsi      # 0xa0aa
movl $0xb, %edx
xorl %eax, %eax
callq 0x34c0
movq (%rbx), %rcx
leaq 0x5caf(%rip), %rdi      # 0xa0c6
movl $0x1a, %esi
movl $0x1, %edx
callq 0x3690
movq (%rbx), %rcx
leaq 0x5cb1(%rip), %rdi      # 0xa0e1
movl $0x40, %esi
movl $0x1, %edx
callq 0x3690
movq (%rbx), %rcx
leaq 0x5cd9(%rip), %rdi      # 0xa122
movl $0x26, %esi
movl $0x1, %edx
callq 0x3690
movq 0x9b69(%rip), %rax      # 0xdfc8
movq (%rax), %rcx
leaq 0x5ce0(%rip), %rdi      # 0xa149
movl $0x7, %esi
movl $0x1, %edx
callq 0x3690
movl $0x1, %edi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/xs.cc
// Function: max_yoffset()
int
max_yoffset(void)
{
 int len, ret;

 if (mode == BROWSE)
  len = cur_list.size() - 1;
 else
  len = default_list.size() - 1;

 ret = len - display_area_ymax;
 return ret < 0 ? 0 : ret;
}

// Assembly:
cmpl $0x1, 0x9ff8(%rip)      # 0xe4e8
leaq 0x9f81(%rip), %rax      # 0xe478
leaq 0x9f82(%rip), %rcx      # 0xe480
leaq 0x9f93(%rip), %rdx      # 0xe498
cmoveq %rcx, %rdx
leaq 0x9f80(%rip), %rcx      # 0xe490
movq (%rdx), %rdx
cmoveq %rax, %rcx
subq (%rcx), %rdx
shrq $0x6, %rdx
leaq 0xa047(%rip), %rax      # 0xe56c
movl (%rax), %ecx
notl %ecx
addl %edx, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/io.cc
// Function: dont_show(char const*)
bool
dont_show(const char * name)
{
 /* don't show current, up, hidden if not flag */
 if (mode == BROWSE) {
  if (strcmp(name, "..") == 0)
   return true;
  
  if (!show_hidden_files && name[0] == '.')
   return true;
 } else {
  if (!NeedleGiven)
   return false;

  if (!Needle)
   return false;

  /* FIXME case-insensitive comparison */
  //if (strcasecmp(name, Needle)) {
  return !strstr(name, Needle);
 }

 return false;
}

// Assembly:
leaq 0x9444(%rip), %rax      # 0xe4e8
cmpl $0x1, (%rax)
jne 0x50c5
cmpb $0x2e, (%rdi)
jne 0x50ff
cmpb $0x2e, 0x1(%rdi)
jne 0x50f1
movb $0x1, %al
cmpb $0x0, 0x2(%rdi)
je 0x50f0
leaq 0x9429(%rip), %rcx      # 0xe4ec
jmp 0x50fa
leaq 0x93e4(%rip), %rax      # 0xe4b0
cmpb $0x1, (%rax)
jne 0x50ff
leaq 0x93d0(%rip), %rax      # 0xe4a8
movq (%rax), %rsi
testq %rsi, %rsi
je 0x50ff
pushq %rax
callq 0x30b0
testq %rax, %rax
sete %al
addq $0x8, %rsp
retq
leaq 0x93f4(%rip), %rcx      # 0xe4ec
movb $0x1, %al
cmpb $0x0, (%rcx)
je 0x50f0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/io.cc
// Function: cur_pos_adjust(int, bool)
void
cur_pos_adjust(int n, bool wrap_around)
{
 int newpos = CurrPosition + n;
 int max, min;

 if (mode == LIST)
  max = default_list.size() - 1;
 else
  max = cur_list.size() - 1;

 min = 0;

 if (newpos < min) {
  if (opt_no_wrap || !wrap_around)
   return;

  newpos = max;
  yoffset = max_yoffset();
 }

 if (newpos > max) {
  if (opt_no_wrap || !wrap_around)
   return;

  newpos = min;
  yoffset = 0;
 }

 CurrPosition = newpos;
 // scrolling...
 if (CurrPosition-yoffset >= display_area_ymax)
  ++yoffset;

 if (yoffset > 0 && CurrPosition == yoffset)
  --yoffset;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x8561(%rip), %rbx      # 0xe4b4
leaq 0x858e(%rip), %rax      # 0xe4e8
leaq 0x852f(%rip), %rcx      # 0xe490
leaq 0x8(%rcx), %rdx
leaq 0x850c(%rip), %r8       # 0xe478
cmpl $0x0, (%rax)
leaq 0x8(%r8), %rax
cmoveq %rdx, %rax
movq (%rax), %r14
cmoveq %rcx, %r8
subq (%r8), %r14
shrq $0x6, %r14
decl %r14d
addl (%rbx), %edi
js 0x5fbe
cmpl %r14d, %edi
jle 0x5fdf
testb %sil, %sil
je 0x602a
leaq 0x854c(%rip), %rax      # 0xe4ed
cmpb $0x0, (%rax)
jne 0x602a
leaq 0x85cb(%rip), %rax      # 0xe57c
movl $0x0, (%rax)
xorl %eax, %eax
xorl %r14d, %r14d
jmp 0x5feb
testb %sil, %sil
je 0x602a
leaq 0x8523(%rip), %rax      # 0xe4ed
cmpb $0x0, (%rax)
jne 0x602a
callq 0x44e9
leaq 0x85a1(%rip), %rcx      # 0xe57c
movl %eax, (%rcx)
jmp 0x5feb
leaq 0x8596(%rip), %rax      # 0xe57c
movl (%rax), %eax
movl %edi, %r14d
movl %r14d, (%rbx)
movl %r14d, %ecx
subl %eax, %ecx
leaq 0x8572(%rip), %rdx      # 0xe56c
xorl %esi, %esi
cmpl (%rdx), %ecx
setge %sil
addl %esi, %eax
setg %dl
cmpl %eax, %r14d
sete %cl
andb %dl, %cl
orb %cl, %sil
cmpb $0x1, %sil
jne 0x602a
decl %r14d
testb %cl, %cl
cmovnel %r14d, %eax
leaq 0x8554(%rip), %rcx      # 0xe57c
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/io.cc
// Function: entry_nr_exists(unsigned int)
bool
entry_nr_exists(unsigned int nr)
{
 if (mode == LIST)
  return nr < default_list.size();
 else if (mode == BROWSE)
  return nr < cur_list.size();

 return false;
}

// Assembly:
leaq 0x84af(%rip), %rax      # 0xe4e8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x604f
testl %eax, %eax
jne 0x606a
movl %edi, %eax
leaq 0x8443(%rip), %rcx      # 0xe490
jmp 0x6058
movl %edi, %eax
leaq 0x8420(%rip), %rcx      # 0xe478
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x6, %rdx
cmpq %rax, %rdx
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Linkerist[P]xs/src/io.cc
// Function: current_entry[abi:cxx11]()
string
current_entry(void)
{
 string res;

 if (mode == LIST) {
  if (default_list.empty())
   return ".";

  res = default_list[CurrPosition].second;
 } else if (mode == BROWSE) {
  if (cur_list.empty())
   return string(".");

  res = cur_list[CurrPosition].second;
 }

 return res == "" ? "." : res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8455(%rip), %rax      # 0xe4e8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x60d0
testl %eax, %eax
jne 0x6100
leaq 0x83eb(%rip), %rcx      # 0xe490
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jne 0x60e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x40f5(%rip), %rsi      # 0xa1b1
leaq 0x40ef(%rip), %rdx      # 0xa1b2
movq %rbx, %rdi
callq 0x4b0e
jmp 0x6168
leaq 0x83a1(%rip), %rcx      # 0xe478
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x614b
leaq 0x83cd(%rip), %rcx      # 0xe4b4
movslq (%rcx), %rcx
shlq $0x6, %rcx
leaq (%rax,%rcx), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0x31e0
leaq 0x428c(%rip), %rsi      # 0xa393
leaq 0x8(%rsp), %rdi
callq 0x30e0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x6133
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4a20
jmp 0x6168
leaq 0x4077(%rip), %rsi      # 0xa1b1
leaq 0x4071(%rip), %rdx      # 0xa1b2
movq %rbx, %rdi
callq 0x4b0e
jmp 0x6168
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4058(%rip), %rsi      # 0xa1b1
leaq 0x4052(%rip), %rdx      # 0xa1b2
movq %rbx, %rdi
callq 0x4b0e
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x617f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x6192
jmp 0x6192
jmp 0x6192
jmp 0x6192
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x61ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3350
movq %rbx, %rdi
callq 0x3620