LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: MechaDragonX[P]CPPCollections/queue.cpp
// Function: Queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Queue<T>::add(T value) {
    if(head_ == nullptr)
        head_ = new DoubleListNode<T>{ value, nullptr, tail_ };
        // tail = nullptr in this case
    else if(size_ == 1) {
        // Set tail to new value
        tail_ = new DoubleListNode<T>{ value, head_, nullptr };
        // Make head => tail (forward link)
        head_->next = tail_;
    }
    else {
        // Make a new node with the passed value that is forward linked to nullptr
        DoubleListNode<T>* neo = new DoubleListNode<T>{ value, tail_, nullptr };
        // Make tail => neo
        tail_->next = neo;
        // Make neo the new tail
        tail_ = neo;
    }

    size_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0xd622
movl $0x30, %edi
callq 0x41d0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x40c0
jmp 0xd5e2
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq $0x0, 0x20(%rcx)
movq 0x10(%rax), %rdx
movq %rdx, 0x28(%rcx)
movq %rcx, 0x8(%rax)
jmp 0xd706
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x41e0
jmp 0xd719
movq -0x30(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0xd697
movl $0x30, %edi
callq 0x41d0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x40c0
jmp 0xd64b
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rcx)
movq $0x0, 0x28(%rcx)
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0xd704
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x41e0
jmp 0xd719
movl $0x30, %edi
callq 0x41d0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x40c0
jmp 0xd6b6
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq 0x10(%rax), %rdx
movq %rdx, 0x20(%rcx)
movq $0x0, 0x28(%rcx)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x10(%rax), %rcx
movq %rdx, 0x28(%rcx)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xd704
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x41e0
jmp 0xd719
jmp 0xd706
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4300
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: MechaDragonX[P]CPPCollections/queue.cpp
// Function: Queue<int>::remove()
void Queue<T>::remove() {
    DoubleListNode<T>* oldHead = head_;
    // Make value after head point back to nullptr
    head_->next->previous = nullptr;
    delete oldHead;

    size_--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xbc58
movq -0x18(%rbp), %rdi
movl $0x18, %esi
callq 0x41e0
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: MechaDragonX[P]CPPCollections/stack.cpp
// Function: Stack<int>::toString[abi:cxx11]()
std::string Stack<T>::toString() {
    DoubleListNode<T>* current = tail_;
    std::string output = "";
    // Print each element backwards so it looks like the back is facing the element in front of it
    while(current != nullptr) {
        // If type is Student
        if constexpr (std::is_same<T, Student>::value)
            output += current->value.toString(false) + "\n";
        // If type is std::string
        else if constexpr (std::is_same<T, std::string>::value)
            output += current->value + "\n";
        // Otherwise, it's a primitive
        else
            output += std::to_string(current->value) + "\n";

        current = current->previous;
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4310
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x72d1(%rip), %rsi      # 0x153be
callq 0x4b60
jmp 0xe0f4
leaq -0x1a(%rbp), %rdi
callq 0x4210
cmpq $0x0, -0x18(%rbp)
je 0xe1b1
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x4c60
jmp 0xe119
leaq 0x729d(%rip), %rdx      # 0x153bd
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4c10
jmp 0xe12f
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4270
jmp 0xe13e
leaq -0x50(%rbp), %rdi
callq 0x4120
leaq -0x70(%rbp), %rdi
callq 0x4120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe0fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x4210
jmp 0xe1dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xe1d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xe1a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4120
leaq -0x70(%rbp), %rdi
callq 0x4120
jmp 0xe1d4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xe1c4
movq -0x80(%rbp), %rdi
callq 0x4120
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x4120
movq -0x28(%rbp), %rdi
callq 0x4300
nopw %cs:(%rax,%rax)
// File: MechaDragonX[P]CPPCollections/student.cpp
// Function: Student::Student()
Student::Student() {
    // Initialize RNG with current time as seed
    // srand(time(nullptr));

    // id_ = rand() % 10000 + 1;
    givenName_ = "";
    surname_ = "";
    coursesTaken_ = {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x42a0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x42a0
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x10970
movq -0x30(%rbp), %rdi
leaq 0x54d1(%rip), %rsi      # 0x153be
callq 0x4290
jmp 0xfef4
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq 0x54bb(%rip), %rsi      # 0x153be
callq 0x4290
jmp 0xff0a
leaq -0x28(%rbp), %rdi
callq 0x10990
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x109b0
jmp 0xff2a
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8870
movq -0x40(%rbp), %rdi
callq 0x4120
movq -0x30(%rbp), %rdi
callq 0x4120
movq -0x10(%rbp), %rdi
callq 0x4300
// File: MechaDragonX[P]CPPCollections/student.cpp
// Function: Student::removeCourse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Student::removeCourse(std::string courseId) {
    if(std::find(coursesTaken_.begin(), coursesTaken_.end(), courseId) != coursesTaken_.end()) {
        coursesTaken_.erase(std::find(coursesTaken_.begin(), coursesTaken_.end(), courseId));
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x40, %rdi
callq 0x10ab0
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x40, %rdi
callq 0x10ae0
movq -0x70(%rbp), %rdx
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x10a60
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x40, %rdi
callq 0x10ae0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10a20
testb $0x1, %al
jne 0x10296
jmp 0x102fc
movq -0x68(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x78(%rbp)
addq $0x40, %rdi
callq 0x10ab0
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x40, %rdi
callq 0x10ae0
movq -0x70(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x10a60
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x10c20
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x10bb0
movq %rax, -0x60(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x10300
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nop
// File: Sweet-john[P]Linux_bash/OS.cpp
// Function: checkSpecialOrder(char* const*)
bool checkSpecialOrder(char *const argv[])
{
 bool check = false;
 if (strcmp(argv[0],"go")==0)
	 {check = true ; go(argv);}
 else if
	 (strcmp(argv[0],"history")==0) {check = true ; printHistory();}
 else if
	 (strcmp(argv[0],"pid")==0) {check = true ; printPid();}
 else if 
	 (strcmp(argv[0],"continue")==0) {check = true ; cont(argv[1]);}
 else if 
	 (strcmp(argv[0],"jobs")==0) {check = true ; printJobs();}
 else if 
	 (strcmp(argv[0],"status")==0) {check = true ; printStatus();}
 return check;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3b56(%rip), %rsi      # 0x6004
callq 0x21e0
cmpl $0x0, %eax
jne 0x24ca
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25a0
jmp 0x258c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3b2f(%rip), %rsi      # 0x6007
callq 0x21e0
cmpl $0x0, %eax
jne 0x24f0
movb $0x1, -0x9(%rbp)
callq 0x25f0
jmp 0x258a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3b11(%rip), %rsi      # 0x600f
callq 0x21e0
cmpl $0x0, %eax
jne 0x2513
movb $0x1, -0x9(%rbp)
callq 0x2650
jmp 0x2588
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3af2(%rip), %rsi      # 0x6013
callq 0x21e0
cmpl $0x0, %eax
jne 0x253e
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4790
jmp 0x2586
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ad0(%rip), %rsi      # 0x601c
callq 0x21e0
cmpl $0x0, %eax
jne 0x2561
movb $0x1, -0x9(%rbp)
callq 0x48d0
jmp 0x2584
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ab2(%rip), %rsi      # 0x6021
callq 0x21e0
cmpl $0x0, %eax
jne 0x2582
movb $0x1, -0x9(%rbp)
callq 0x4990
jmp 0x2584
jmp 0x2586
jmp 0x2588
jmp 0x258a
jmp 0x258c
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sweet-john[P]Linux_bash/OS.cpp
// Function: printPid()
void printPid()
{
 int i = 0;
 int size = pidList.size();
 int j = 1;
 if (i<size-5)
  i = size - 5; 
  while(i<size)
  {
   cout<<"["<<size-i<<"] "<<pidList[size-j]<<"\n";
   i++;
   j++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x10772(%rip), %rdi     # 0x12dd8
callq 0x2ba0
movl %eax, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x5, %ecx
cmpl %ecx, %eax
jge 0x268b
movl -0x8(%rbp), %eax
subl $0x5, %eax
movl %eax, -0x4(%rbp)
jmp 0x268d
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x270c
movq 0x6934(%rip), %rdi      # 0x8fd0
leaq 0x39b5(%rip), %rsi      # 0x6058
callq 0x2150
movq %rax, %rdi
movl -0x8(%rbp), %esi
subl -0x4(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0x399a(%rip), %rsi      # 0x605a
callq 0x2150
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movslq %eax, %rsi
leaq 0x106ff(%rip), %rdi     # 0x12dd8
callq 0x2bc0
movq -0x18(%rbp), %rdi
movl (%rax), %esi
callq 0x2270
movq %rax, %rdi
leaq 0x39f6(%rip), %rsi      # 0x60e9
callq 0x2150
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x268d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sweet-john[P]Linux_bash/OS.cpp
// Function: setHistory()
void setHistory()
{
 historyCommand[historyCount]=(char *)malloc(50*sizeof(char));
 memset(historyCommand[historyCount],0,50*sizeof(char));
 strcpy(historyCommand[historyCount],Command);
 historyCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x32, %edi
callq 0x21c0
movq %rax, %rdx
movslq 0x10698(%rip), %rcx     # 0x12dd0
leaq 0x6a51(%rip), %rax      # 0x9190
movq %rdx, (%rax,%rcx,8)
movslq 0x10686(%rip), %rcx     # 0x12dd0
leaq 0x6a3f(%rip), %rax      # 0x9190
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x20d0
movslq 0x10668(%rip), %rcx     # 0x12dd0
leaq 0x6a21(%rip), %rax      # 0x9190
movq (%rax,%rcx,8), %rdi
leaq 0x10676(%rip), %rsi     # 0x12df0
callq 0x2140
movl 0x1064b(%rip), %eax     # 0x12dd0
addl $0x1, %eax
movl %eax, 0x10642(%rip)     # 0x12dd0
popq %rbp
retq
// File: Sweet-john[P]Linux_bash/OS.cpp
// Function: execute(char* const*)
void execute(char *const argv[])
{ 
 pid=fork();
 int success;
 if (pid!=0)
 { /*waitpid(pid,&success,0);
   if (WEXITSTATUS(success)==0)
	{
	setPid(pid);
	}*/
	waitid(P_PID,pid,&info,WEXITED|WSTOPPED);
	setPid(pid);
 }
 else
 {
	if (execvp(argv[0],argv)<0)
        {
		perror("Exec error ");
		exit(-1);
	}
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2040
movl %eax, 0x10669(%rip)     # 0x12e40
cmpl $0x0, 0x10662(%rip)     # 0x12e40
je 0x2809
movl 0x1065a(%rip), %esi     # 0x12e40
movl $0x1, %edi
leaq 0x10656(%rip), %rdx     # 0x12e48
movl $0x6, %ecx
callq 0x2070
movl 0x1063e(%rip), %edi     # 0x12e40
callq 0x2790
jmp 0x2836
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jge 0x2834
leaq 0x3838(%rip), %rdi      # 0x605d
callq 0x2110
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21a0
jmp 0x2836
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Sweet-john[P]Linux_bash/OS.cpp
// Function: main
int main()
{

 signal(SIGINT,kill_sig_handler);
 signal(SIGTSTP,stp_sig_handler);

 while(1)
 {
 prompt();
 cin.getline(Command,80);

 if (strcmp(Command,"exit")==0)
	{
	freeMemory();
	exit(0);
	}
 else if (Command == NULL)
 continue;
 
 setHistory();
 //check space
 char *temp = strtok(Command," ");
 vector<char*>obj;
 while (temp)
 	{
  	obj.push_back(temp);
  	temp = strtok(NULL," ");
 	}
 
 //obj to char
 char* a[obj.size()];
 int s;
 for (s = 0; s < obj.size() ;s++ )
	{
	  a[s]=obj[s];
 	}
 a[s]=NULL;

 multiple(a,obj.size());
 }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2, %edi
leaq 0x1cc5(%rip), %rsi      # 0x45e0
callq 0x2180
movl $0x14, %edi
leaq 0x1d64(%rip), %rsi      # 0x4690
callq 0x2180
callq 0x2840
movq 0x66a3(%rip), %rdi      # 0x8fe0
leaq 0x104ac(%rip), %rsi     # 0x12df0
movl $0x50, %edx
callq 0x2060
leaq 0x1049b(%rip), %rdi     # 0x12df0
leaq 0x3714(%rip), %rsi      # 0x6070
callq 0x21e0
cmpl $0x0, %eax
jne 0x2972
callq 0x28c0
xorl %edi, %edi
callq 0x21a0
jmp 0x2974
callq 0x2720
leaq 0x10470(%rip), %rdi     # 0x12df0
leaq 0x36e7(%rip), %rsi      # 0x606e
callq 0x2250
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2be0
cmpq $0x0, -0x10(%rbp)
je 0x29df
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2c00
jmp 0x29af
xorl %eax, %eax
movl %eax, %edi
leaq 0x36b4(%rip), %rsi      # 0x606e
callq 0x2250
movq %rax, -0x10(%rbp)
jmp 0x2999
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2cb0
jmp 0x2a9b
leaq -0x28(%rbp), %rdi
callq 0x2c70
movq %rax, %rcx
movq %rcx, %rax
movq %rsp, %rdx
movq %rdx, -0x40(%rbp)
leaq 0xf(,%rcx,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2c70
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a60
movslq -0x4c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2c90
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rdx
movslq -0x4c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x2a19
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
leaq -0x28(%rbp), %rdi
callq 0x2c70
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x3f90
jmp 0x2a86
movq -0x40(%rbp), %rax
movq %rax, %rsp
leaq -0x28(%rbp), %rdi
callq 0x2cb0
jmp 0x2931
movq -0x30(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
nop
// File: Sweet-john[P]Linux_bash/OS2.cpp
// Function: multiple(char**, int)
bool multiple(char*argv[],int size)
{
 int n = 1;
 bool check = false;
	for (int i = 0; i<size; i++)
	{
	 	if (strchr(argv[i],';')!=NULL||i==size-1)
		{
		check = true;
		char* temp[20];
		int j;
		char *out;
		if (strcmp(argv[i],";")!=0)
		out = strtok(argv[i],";");
		for (j = 0; j < n; j++)
			{
			if (j == n-1 && strcmp(argv[i],";")!=0)
			temp[j] = out;
			else if (j == n-1 && strcmp(argv[i],";")==0)
			temp[j] = NULL;
			else
			temp[j] = argv[i+j-n+1];
			}
		temp[j]=NULL;
		if (Redirection(temp,n)) 
			{
			n = 1;
			continue;
			}
		n = 0;
		bool isSpecial = checkSpecialOrder(temp);
		if (!isSpecial)
		execute(temp);
		}
	 n++;
	}
 return check;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4188
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3b, %esi
callq 0x2090
cmpq $0x0, %rax
jne 0x3fed
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4171
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x208b(%rip), %rsi      # 0x608f
callq 0x21e0
cmpl $0x0, %eax
je 0x402d
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x206e(%rip), %rsi      # 0x608f
callq 0x2250
movq %rax, -0xd0(%rbp)
movl $0x0, -0xc4(%rbp)
movl -0xc4(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x410e
movl -0xc4(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x408b
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2026(%rip), %rsi      # 0x608f
callq 0x21e0
cmpl $0x0, %eax
je 0x408b
movq -0xd0(%rbp), %rcx
movslq -0xc4(%rbp), %rax
movq %rcx, -0xc0(%rbp,%rax,8)
jmp 0x40f8
movl -0xc4(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x40cd
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1fe1(%rip), %rsi      # 0x608f
callq 0x21e0
cmpl $0x0, %eax
jne 0x40cd
movslq -0xc4(%rbp), %rax
movq $0x0, -0xc0(%rbp,%rax,8)
jmp 0x40f6
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0xc4(%rbp), %ecx
subl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movslq -0xc4(%rbp), %rax
movq %rcx, -0xc0(%rbp,%rax,8)
jmp 0x40f8
jmp 0x40fa
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x4037
movslq -0xc4(%rbp), %rax
movq $0x0, -0xc0(%rbp,%rax,8)
leaq -0xc0(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x41a0
testb $0x1, %al
jne 0x4136
jmp 0x413f
movl $0x1, -0x10(%rbp)
jmp 0x417a
movl $0x0, -0x10(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2490
andb $0x1, %al
movb %al, -0xd1(%rbp)
testb $0x1, -0xd1(%rbp)
jne 0x416f
leaq -0xc0(%rbp), %rdi
callq 0x27c0
jmp 0x4171
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3fb4
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sweet-john[P]Linux_bash/OS2.cpp
// Function: pipe(char**, char**)
void pipe(char* input[], char* output[])
{
int fd[2];
 pipe(fd);
 if (fork()!=0)
 {
  close(fd[0]);
  int fdo = dup(STDOUT_FILENO);
  close(1);
  dup(fd[1]);
  close(fd[1]);
  bool isSpecial = checkSpecialOrder(input);
  if (!isSpecial)
  execute(input);
  dup2(fdo,STDOUT_FILENO);
  wait(NULL);
 }
else
 {
  close(fd[1]);
  close(0);
  dup(fd[0]);
  close(fd[0]);
  bool isSpecial = checkSpecialOrder(output);
  if (!isSpecial)
  execute(output);
  exit(0); 
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x21d0
callq 0x2040
cmpl $0x0, %eax
je 0x4597
movl -0x18(%rbp), %edi
callq 0x2290
movl $0x1, %edi
callq 0x2220
movl %eax, -0x1c(%rbp)
movl $0x1, %edi
callq 0x2290
movl -0x14(%rbp), %edi
callq 0x2220
movl -0x14(%rbp), %edi
callq 0x2290
movq -0x8(%rbp), %rdi
callq 0x2490
andb $0x1, %al
movb %al, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x457f
movq -0x8(%rbp), %rdi
callq 0x27c0
movl -0x1c(%rbp), %edi
movl $0x1, %esi
callq 0x2130
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
jmp 0x45da
movl -0x14(%rbp), %edi
callq 0x2290
xorl %edi, %edi
callq 0x2290
movl -0x18(%rbp), %edi
callq 0x2220
movl -0x18(%rbp), %edi
callq 0x2290
movq -0x10(%rbp), %rdi
callq 0x2490
andb $0x1, %al
movb %al, -0x1e(%rbp)
testb $0x1, -0x1e(%rbp)
jne 0x45d3
movq -0x10(%rbp), %rdi
callq 0x27c0
xorl %edi, %edi
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
// File: Sweet-john[P]Linux_bash/OS3.cpp
// Function: kill_sig_handler(int)
void kill_sig_handler(int sig)
{
	kill(pid,SIGINT);
	
	for (int i=0; i<jobList.size();i++)
	{
		if (pid==jobList[i].id)
			jobList[i].status = TERMINATE;
	}
	printf("\nThe current process has been killed\n");	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0xe84e(%rip), %rax      # 0x12e40
movl (%rax), %edi
movl $0x2, %esi
callq 0x21f0
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xe8bc(%rip), %rdi      # 0x12ed0
callq 0x4a50
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x466f
leaq 0xe814(%rip), %rax      # 0x12e40
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0x8(%rbp), %rsi
leaq 0xe894(%rip), %rdi      # 0x12ed0
callq 0x4a70
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jne 0x4662
movslq -0x8(%rbp), %rsi
leaq 0xe87a(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl $0x3, 0x4(%rax)
jmp 0x4664
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4605
leaq 0x1a2d(%rip), %rdi      # 0x60a3
movb $0x0, %al
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sweet-john[P]Linux_bash/OS3.cpp
// Function: stp_sig_handler(int)
void stp_sig_handler(int sig)
{
	bool check = false;
	int sus;
	kill(pid,SIGSTOP);
	
	for (int i=0; i<jobList.size();i++)
	{
		if (pid!=jobList[i].id)
			continue;
		else
			{check = true; jobList[i].status = SUSPEND; sus = i+1; break;}
	}
	
	if (check == false)	
	{
		job temp;
		temp.id = pid;
		temp.status = SUSPEND;
		jobList.push_back(temp);
		sus = jobList.size();
	}
	printf("[%d] Suspend\n",sus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
leaq 0xe79a(%rip), %rax      # 0x12e40
movl (%rax), %edi
movl $0x13, %esi
callq 0x21f0
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xe808(%rip), %rdi      # 0x12ed0
callq 0x4a50
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x4732
leaq 0xe760(%rip), %rax      # 0x12e40
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0xe7e0(%rip), %rdi      # 0x12ed0
callq 0x4a70
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
je 0x4701
jmp 0x4727
movb $0x1, -0x5(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0xe7c0(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl $0x2, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4732
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x46b9
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4771
leaq 0xe6fa(%rip), %rax      # 0x12e40
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x2, -0x14(%rbp)
leaq 0xe777(%rip), %rdi      # 0x12ed0
leaq -0x18(%rbp), %rsi
callq 0x4a90
leaq 0xe767(%rip), %rdi      # 0x12ed0
callq 0x4a50
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x194e(%rip), %rdi      # 0x60c9
movb $0x0, %al
callq 0x2030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sweet-john[P]Linux_bash/OS3.cpp
// Function: cont(char*)
void cont(char *arg)
{
	int i = atoi(arg);
	
	if (jobList[i-1].status == SUSPEND)
	{
	
	kill(jobList[i-1].id,SIGCONT);
	pid = jobList[i-1].id;
	jobList[i-1].status = RUN;
	
	waitid(P_PID,jobList[i-1].id,&info,WEXITED|WSTOPPED);
	
	if (info.si_code == CLD_STOPPED)
	jobList[i-1].status = SUSPEND;
	else if (info.si_code == CLD_EXITED || info.si_code == CLD_KILLED)
	jobList[i-1].status = TERMINATE;
	
	}
	else
	printf("Not a suspend job!\n");	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2240
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe718(%rip), %rdi      # 0x12ed0
callq 0x4a70
cmpl $0x2, 0x4(%rax)
jne 0x48b6
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe6f9(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl (%rax), %edi
movl $0x12, %esi
callq 0x21f0
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe6d8(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl (%rax), %ecx
leaq 0xe63a(%rip), %rax      # 0x12e40
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe6b8(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl $0x1, 0x4(%rax)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe69c(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl (%rax), %esi
movl $0x1, %edi
leaq 0xe601(%rip), %rdx      # 0x12e48
movl $0x6, %ecx
callq 0x2070
leaq 0xe5f0(%rip), %rax      # 0x12e48
cmpl $0x5, 0x8(%rax)
jne 0x487c
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe662(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl $0x2, 0x4(%rax)
jmp 0x48b4
leaq 0xe5c5(%rip), %rax      # 0x12e48
cmpl $0x1, 0x8(%rax)
je 0x4896
leaq 0xe5b8(%rip), %rax      # 0x12e48
cmpl $0x2, 0x8(%rax)
jne 0x48b2
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0xe62a(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl $0x3, 0x4(%rax)
jmp 0x48b4
jmp 0x48c4
leaq 0x181a(%rip), %rdi      # 0x60d7
movb $0x0, %al
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Sweet-john[P]Linux_bash/OS3.cpp
// Function: printJobs()
void printJobs()
{
	for (int i=0; i<jobList.size();i++)
	{
		switch (jobList[i].status)
		{
		case 1: printf("[%d] Running\n",i+1); break;
		case 2: printf("[%d] Suspended\n",i+1); break;
		case 3: printf("[%d] Terminated\n",i+1); break;
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xe5e2(%rip), %rdi      # 0x12ed0
callq 0x4a50
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x4984
movslq -0x4(%rbp), %rsi
leaq 0xe5c2(%rip), %rdi      # 0x12ed0
callq 0x4a70
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x4934
jmp 0x4920
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x494a
jmp 0x492a
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x4960
jmp 0x4974
movl -0x4(%rbp), %esi
addl $0x1, %esi
leaq 0x17aa(%rip), %rdi      # 0x60eb
movb $0x0, %al
callq 0x2030
jmp 0x4974
movl -0x4(%rbp), %esi
addl $0x1, %esi
leaq 0x17a2(%rip), %rdi      # 0x60f9
movb $0x0, %al
callq 0x2030
jmp 0x4974
movl -0x4(%rbp), %esi
addl $0x1, %esi
leaq 0x179c(%rip), %rdi      # 0x6109
movb $0x0, %al
callq 0x2030
jmp 0x4976
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x48df
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: s0sasaki[P]ExecutableBlockchain/compiler.cpp
// Function: Compiler::read(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>>>>&, char const*) const
void Compiler::read(std::vector<std::string> &strtable, const char *src_data) const{
    int32_t c;
    int32_t idx = 0;
    char buf[256];
    bool iscomment = false;
    while((c = *src_data++)) {
        c = toupper(c);
        if(isSep(c, (char *)" \t\r\n()")) {
            if(c == '(') iscomment = true;
            if(c == ')') iscomment = false;
            if(!idx) continue;
            buf[idx] = 0;
            strtable.push_back(buf);
            idx = 0;
            continue;
        }
        if(!iscomment) buf[idx++] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x168(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x0, -0x121(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x3943
movl -0x1c(%rbp), %edi
callq 0x2380
movq -0x168(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x88fd(%rip), %rdx      # 0xc127
movsbl %al, %esi
callq 0x4ac0
testb $0x1, %al
jne 0x383b
jmp 0x391c
cmpl $0x28, -0x1c(%rbp)
jne 0x3848
movb $0x1, -0x121(%rbp)
cmpl $0x29, -0x1c(%rbp)
jne 0x3855
movb $0x0, -0x121(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x385d
jmp 0x37f0
movslq -0x20(%rbp), %rax
movb $0x0, -0x120(%rbp,%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x2360
movq -0x170(%rbp), %rdx
leaq -0x148(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x22d0
jmp 0x38a3
movq -0x178(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x4b10
jmp 0x38b8
leaq -0x148(%rbp), %rdi
callq 0x2140
leaq -0x149(%rbp), %rdi
callq 0x2260
movl $0x0, -0x20(%rbp)
jmp 0x37f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x158(%rbp)
movl %eax, -0x15c(%rbp)
jmp 0x390e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x158(%rbp)
movl %eax, -0x15c(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x2140
leaq -0x149(%rbp), %rdi
callq 0x2260
jmp 0x394c
testb $0x1, -0x121(%rbp)
jne 0x393e
movl -0x1c(%rbp), %eax
movb %al, %cl
movl -0x20(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
cltq
movb %cl, -0x120(%rbp,%rax)
jmp 0x37f0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x158(%rbp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: s0sasaki[P]ExecutableBlockchain/block.cpp
// Function: Block::Block(int const (&) [1024])
Block::Block(const int32_t (&data)[DATA_SIZE]){
    nonce = 0;
    timestamp = time(nullptr);
    for(int32_t i=0; i<sizeof(data)/sizeof(int32_t); i++) 
        this->data[i] = data[i];
    hash = calculateHash();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22e0
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x22e0
movq -0x50(%rbp), %rax
movl $0x0, 0x1040(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x21e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x1048(%rax)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x400, %rax            # imm = 0x400
jae 0x85a8
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x40(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x857a
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8820
jmp 0x85b7
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2290
leaq -0x38(%rbp), %rdi
callq 0x2140
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2140
movq -0x50(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: s0sasaki[P]ExecutableBlockchain/block.cpp
// Function: Block::mineBlock(unsigned int const&)
void Block::mineBlock(const uint32_t &difficulty){
    char cstr[difficulty + 1];
    for (uint32_t i = 0; i < difficulty; ++i)
        cstr[i] = '0';
    cstr[difficulty] = '\0';
    std::string str(cstr);

    //std::cout << "Mining block... " << std::flush;
    do{
        nonce++;
        hash = calculateHash();
    }while (hash.substr(0, difficulty) != str);
    //std::cout << hash << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0xa8(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x8677
movq -0xa8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb $0x30, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8653
movq -0xa8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2360
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x22d0
jmp 0x86b1
leaq -0x49(%rbp), %rdi
callq 0x2260
movq -0xb0(%rbp), %rsi
movl 0x1040(%rsi), %eax
incl %eax
movl %eax, 0x1040(%rsi)
leaq -0x80(%rbp), %rdi
callq 0x8820
jmp 0x86da
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2290
leaq -0x80(%rbp), %rdi
callq 0x2140
movq -0xb0(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
leaq -0xa0(%rbp), %rdi
callq 0x2230
jmp 0x8714
leaq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x89a0
movb %al, -0xb9(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2140
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x86ba
leaq -0x48(%rbp), %rdi
callq 0x2140
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x2260
jmp 0x8785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2140
movq -0x58(%rbp), %rdi
callq 0x2350
nop
// File: s0sasaki[P]ExecutableBlockchain/block.cpp
// Function: Block::calculateHash[abi:cxx11]() const
inline std::string Block::calculateHash() const{
    std::stringstream ss;
    ss << prev_hash << timestamp << nonce;
    for(uint32_t i=0; i<DATA_SIZE; i++)
        ss << data[i];
    return sha256(ss.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2170
movq -0x1d8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
addq $0x20, %rsi
callq 0x21c0
movq %rax, -0x1d0(%rbp)
jmp 0x887b
movq -0x1d0(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movq 0x1048(%rax), %rsi
callq 0x2370
movq %rax, -0x1f0(%rbp)
jmp 0x889e
movq -0x1f0(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movl 0x1040(%rax), %esi
callq 0x22b0
jmp 0x88b9
movl $0x0, -0x1a8(%rbp)
cmpl $0x400, -0x1a8(%rbp)    # imm = 0x400
jae 0x8915
movq -0x1d8(%rbp), %rax
leaq -0x188(%rbp), %rdi
movl -0x1a8(%rbp), %ecx
movl 0x40(%rax,%rcx,4), %esi
callq 0x2340
jmp 0x88ee
jmp 0x88f0
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0x88c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x8985
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2200
jmp 0x892a
movq -0x1e8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xa390
jmp 0x893f
leaq -0x1c8(%rbp), %rdi
callq 0x2140
leaq -0x198(%rbp), %rdi
callq 0x2180
movq -0x1e0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2140
leaq -0x198(%rbp), %rdi
callq 0x2180
movq -0x1a0(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: s0sasaki[P]ExecutableBlockchain/blockchain.cpp
// Function: Blockchain::Blockchain()
Blockchain::Blockchain(){
    int32_t genesis_data[Block::DATA_SIZE];
    Block genesis_block(genesis_data);
    genesis_block.mineBlock(difficulty);
    chain.emplace_back(genesis_block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2080, %rsp           # imm = 0x2080
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2078(%rbp)
movq %rdi, %rax
movq %rax, -0x2080(%rbp)
callq 0x8d30
movq -0x2078(%rbp), %rax
movl $0x3, 0x18(%rax)
leaq -0x2060(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x8520
jmp 0x8a1c
movq -0x2080(%rbp), %rsi
addq $0x18, %rsi
leaq -0x2060(%rbp), %rdi
callq 0x8600
jmp 0x8a35
movq -0x2080(%rbp), %rdi
leaq -0x2060(%rbp), %rsi
callq 0x8d50
jmp 0x8a4a
leaq -0x2060(%rbp), %rdi
callq 0x2ad0
addq $0x2080, %rsp           # imm = 0x2080
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2068(%rbp)
movl %eax, -0x206c(%rbp)
jmp 0x8a91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2068(%rbp)
movl %eax, -0x206c(%rbp)
leaq -0x2060(%rbp), %rdi
callq 0x2ad0
movq -0x2078(%rbp), %rdi
callq 0x3490
movq -0x2068(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: s0sasaki[P]ExecutableBlockchain/blockchain.cpp
// Function: Blockchain::isValid() const
bool Blockchain::isValid() const{
    for (auto block: chain)
        if(!block.isValid(difficulty)) return false;
    std::string prev_hash = chain.front().hash;
    for(uint32_t i=1; i<chain.size(); i++){
        if(prev_hash != chain[i].prev_hash) return false;
        prev_hash = chain[i].hash;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10d0, %rsp           # imm = 0x10D0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10b8(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8dc0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8df0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8e20
testb $0x1, %al
jne 0x8afe
jmp 0x8bb2
leaq -0x20(%rbp), %rdi
callq 0x8e60
movq %rax, %rsi
leaq -0x1078(%rbp), %rdi
movq %rdi, -0x10c8(%rbp)
callq 0x8e80
movq -0x10b8(%rbp), %rsi
movq -0x10c8(%rbp), %rdi
addq $0x18, %rsi
callq 0x8790
movb %al, -0x10b9(%rbp)
jmp 0x8b3c
movb -0x10b9(%rbp), %al
testb $0x1, %al
jne 0x8b7b
jmp 0x8b48
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1088(%rbp)
jmp 0x8b85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1080(%rbp)
movl %eax, -0x1084(%rbp)
leaq -0x1078(%rbp), %rdi
callq 0x2ad0
jmp 0x8cc3
movl $0x0, -0x1088(%rbp)
leaq -0x1078(%rbp), %rdi
callq 0x2ad0
movl -0x1088(%rbp), %eax
testl %eax, %eax
je 0x8ba2
jmp 0x8b9d
jmp 0x8cb5
jmp 0x8ba4
leaq -0x20(%rbp), %rdi
callq 0x8f00
jmp 0x8ae8
movq -0x10b8(%rbp), %rdi
callq 0x8f20
movq %rax, %rsi
leaq -0x10a8(%rbp), %rdi
callq 0x20e0
movl $0x1, -0x10ac(%rbp)
movq -0x10b8(%rbp), %rdi
movl -0x10ac(%rbp), %eax
movq %rax, -0x10d0(%rbp)
callq 0x2aa0
movq %rax, %rcx
movq -0x10d0(%rbp), %rax
cmpq %rcx, %rax
jae 0x8c9b
movq -0x10b8(%rbp), %rdi
movl -0x10ac(%rbp), %eax
movl %eax, %esi
callq 0x8f50
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x10a8(%rbp), %rdi
callq 0x89a0
testb $0x1, %al
jne 0x8c30
jmp 0x8c40
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1088(%rbp)
jmp 0x8ca9
movq -0x10b8(%rbp), %rdi
movl -0x10ac(%rbp), %eax
movl %eax, %esi
callq 0x8f50
movq %rax, %rsi
leaq -0x10a8(%rbp), %rdi
callq 0x2040
jmp 0x8c65
jmp 0x8c67
movl -0x10ac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10ac(%rbp)
jmp 0x8bd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1080(%rbp)
movl %eax, -0x1084(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x2140
jmp 0x8cc3
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1088(%rbp)
leaq -0x10a8(%rbp), %rdi
callq 0x2140
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10d0, %rsp           # imm = 0x10D0
popq %rbp
retq
movq -0x1080(%rbp), %rdi
callq 0x2350
nop
// File: s0sasaki[P]ExecutableBlockchain/sha256.cpp
// Function: SHA256::init()
void SHA256::init()
{
    m_h[0] = 0x6a09e667;
    m_h[1] = 0xbb67ae85;
    m_h[2] = 0x3c6ef372;
    m_h[3] = 0xa54ff53a;
    m_h[4] = 0x510e527f;
    m_h[5] = 0x9b05688c;
    m_h[6] = 0x1f83d9ab;
    m_h[7] = 0x5be0cd19;
    m_len = 0;
    m_tot_len = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6a09e667, 0x88(%rax) # imm = 0x6A09E667
movl $0xbb67ae85, 0x8c(%rax) # imm = 0xBB67AE85
movl $0x3c6ef372, 0x90(%rax) # imm = 0x3C6EF372
movl $0xa54ff53a, 0x94(%rax) # imm = 0xA54FF53A
movl $0x510e527f, 0x98(%rax) # imm = 0x510E527F
movl $0x9b05688c, 0x9c(%rax) # imm = 0x9B05688C
movl $0x1f83d9ab, 0xa0(%rax) # imm = 0x1F83D9AB
movl $0x5be0cd19, 0xa4(%rax) # imm = 0x5BE0CD19
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: s0sasaki[P]ExecutableBlockchain/sha256.cpp
// Function: SHA256::update(unsigned char const*, unsigned int)
void SHA256::update(const unsigned char *message, unsigned int len)
{
    unsigned int block_nb;
    unsigned int new_len, rem_len, tmp_len;
    const unsigned char *shifted_message;
    tmp_len = SHA224_256_BLOCK_SIZE - m_len;
    rem_len = len < tmp_len ? len : tmp_len;
    memcpy(&m_block[m_len], message, rem_len);
    if (m_len + len < SHA224_256_BLOCK_SIZE) {
        m_len += len;
        return;
    }
    new_len = len - rem_len;
    block_nb = new_len / SHA224_256_BLOCK_SIZE;
    shifted_message = message + rem_len;
    transform(m_block, 1);
    transform(shifted_message, block_nb);
    rem_len = new_len % SHA224_256_BLOCK_SIZE;
    memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
    m_len = rem_len;
    m_tot_len += (block_nb + 1) << 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movl $0x40, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xa146
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xa14c
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movl 0x4(%rax), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x21a0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x40, %eax
jae 0xa192
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0xa218
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq %rdi, %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x9c10
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x9c10
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x20(%rbp)
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
movl -0x18(%rbp), %eax
shll $0x6, %eax
movl %eax, %eax
addq %rax, %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x21a0
movq -0x38(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
shll $0x6, %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: s0sasaki[P]ExecutableBlockchain/sha256.cpp
// Function: SHA256::final(unsigned char*)
void SHA256::final(unsigned char *digest)
{
    unsigned int block_nb;
    unsigned int pm_len;
    unsigned int len_b;
    int i;
    block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9)
                     < (m_len % SHA224_256_BLOCK_SIZE)));
    len_b = (m_tot_len + m_len) << 3;
    pm_len = block_nb << 6;
    memset(m_block + m_len, 0, pm_len - m_len);
    m_block[m_len] = 0x80;
    SHA2_UNPACK32(len_b, m_block + pm_len - 4);
    transform(m_block, block_nb);
    for (i = 0 ; i < 8; i++) {
        SHA2_UNPACK32(m_h[i], &digest[i << 2]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl 0x4(%rcx), %edx
andl $0x3f, %edx
movl $0x37, %eax
cmpl %edx, %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl (%rcx), %eax
addl 0x4(%rcx), %eax
shll $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movq %rcx, %rdi
addq $0x8, %rdi
movl 0x4(%rcx), %eax
addq %rax, %rdi
movl -0x18(%rbp), %eax
subl 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2110
movq -0x28(%rbp), %rdi
movl 0x4(%rdi), %eax
movb $-0x80, 0x8(%rdi,%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movb %cl, 0x7(%rdi,%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movb %cl, 0x6(%rdi,%rax)
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movb %cl, 0x5(%rdi,%rax)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movb %cl, 0x4(%rdi,%rax)
movq %rdi, %rsi
addq $0x8, %rsi
movl -0x14(%rbp), %edx
callq 0x9c10
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0xa382
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl 0x88(%rax,%rcx,4), %ecx
movb %cl, %sil
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
movb %sil, 0x3(%rcx,%rdx)
movslq -0x20(%rbp), %rcx
movl 0x88(%rax,%rcx,4), %ecx
shrl $0x8, %ecx
movb %cl, %sil
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
movb %sil, 0x2(%rcx,%rdx)
movslq -0x20(%rbp), %rcx
movl 0x88(%rax,%rcx,4), %ecx
shrl $0x10, %ecx
movb %cl, %sil
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
movb %sil, 0x1(%rcx,%rdx)
movslq -0x20(%rbp), %rcx
movl 0x88(%rax,%rcx,4), %eax
shrl $0x18, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa2e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: s0sasaki[P]ExecutableBlockchain/sha256.cpp
// Function: sha256(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string sha256(std::string input)
{
    unsigned char digest[SHA256::DIGEST_SIZE];
    memset(digest,0,SHA256::DIGEST_SIZE);

    SHA256 ctx = SHA256();
    ctx.init();
    ctx.update( (unsigned char*)input.c_str(), input.length());
    ctx.final(digest);

    char buf[2*SHA256::DIGEST_SIZE+1];
    buf[2*SHA256::DIGEST_SIZE] = 0;
    for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
        sprintf(buf+i*2, "%02x", digest[i]);
    return std::string(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rsi, -0x148(%rbp)
movq %rdi, -0x158(%rbp)
movq %rdi, %rax
movq %rax, -0x150(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2110
leaq -0xd8(%rbp), %rdi
xorl %esi, %esi
movl $0xa8, %edx
callq 0x2110
leaq -0xd8(%rbp), %rdi
callq 0xa0a0
movq -0x148(%rbp), %rdi
callq 0x20d0
movq -0x148(%rbp), %rdi
movq %rax, -0x140(%rbp)
callq 0x2310
movq -0x140(%rbp), %rsi
movl %eax, %edx
leaq -0xd8(%rbp), %rdi
callq 0xa110
leaq -0x30(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0xa220
movb $0x0, -0xe0(%rbp)
movl $0x0, -0x124(%rbp)
cmpl $0x20, -0x124(%rbp)
jae 0xa487
leaq -0x120(%rbp), %rdi
movl -0x124(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
movslq -0x124(%rbp), %rax
movzbl -0x30(%rbp,%rax), %edx
leaq 0x1e51(%rip), %rsi      # 0xc2c0
movb $0x0, %al
callq 0x2070
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0xa43f
leaq -0x125(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x2360
movq -0x158(%rbp), %rdi
movq -0x160(%rbp), %rdx
leaq -0x120(%rbp), %rsi
callq 0x22d0
jmp 0xa4b6
leaq -0x125(%rbp), %rdi
callq 0x2260
movq -0x150(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x125(%rbp), %rdi
callq 0x2260
movq -0x130(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: s0sasaki[P]ExecutableBlockchain/vm.cpp
// Function: VM::funcOpRet()
void VM::funcOpRet () { 
    if(rsp == 0) is_halt = true; 
    ip = return_stack[rsp--];  
    ib = return_stack[rsp--];  
    load();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0xa792
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl 0x8(%rdi), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rdi)
cltq
movl 0x3020(%rdi,%rax,4), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rdi), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rdi)
cltq
movl 0x3020(%rdi,%rax,4), %eax
movl %eax, (%rdi)
callq 0xb5d0
addq $0x10, %rsp
popq %rbp
retq
nop