LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Sleepwalking[P]world-octave/test.cpp
// Function: (anonymous namespace)::WaveformSynthesis(double*, int, double**, double**, int, double, int, int, double*)
void WaveformSynthesis(double *f0, int f0_length, double **spectrogram,
    double **aperiodicity, int fft_size, double frame_period, int fs,
    int y_length, double *y) {
  DWORD elapsed_time;
  // Synthesis by the aperiodicity
  printf("\nSynthesis\n");
  elapsed_time = timeGetTime();
  Synthesis(f0, f0_length, spectrogram, aperiodicity,
      fft_size, FRAMEPERIOD, fs, y_length, y);
  printf("WORLD: %d [msec]\n", timeGetTime() - elapsed_time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
leaq 0x8b0(%rip), %rdi       # 0x1c512
movb $0x0, %al
callq 0x1040
callq 0x1b030
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x34(%rbp), %r9d
movl 0x10(%rbp), %r10d
movq 0x18(%rbp), %rax
movsd 0x3f0(%rip), %xmm0      # 0x1c088
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4fe0
callq 0x1b030
movl %eax, %esi
subl -0x38(%rbp), %esi
leaq 0x867(%rip), %rdi       # 0x1c51e
movb $0x0, %al
callq 0x1040
addq $0x50, %rsp
popq %rbp
retq
// File: emr4378[P]FAT-File-System/main.cpp
// Function: main
int main( int argc, char ** argv) {
	Shell *shell;
	if (argc == 1) {
		//no filesystem given
		shell = new Shell(NULL);
		shell->prompt();
	} else if (argc == 2) {
		//filesystem given
		shell = new Shell(argv[1]);
		shell->prompt();
	} else {
		cout << "usage: os1shell [file-system-name]\n";
	}
	delete shell;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x3810
movl $0x20, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x87e0
jmp 0x37db
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9750
jmp 0x387d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x32c0
jmp 0x38aa
cmpl $0x2, -0x8(%rbp)
jne 0x3868
movl $0x20, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x87e0
jmp 0x3839
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9750
jmp 0x387b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x32c0
jmp 0x38aa
movq 0xc761(%rip), %rdi      # 0xffd0
leaq 0x878e(%rip), %rsi      # 0xc004
callq 0x3290
jmp 0x387d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x38a2
movq -0x40(%rbp), %rdi
callq 0xb540
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x32c0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::openFileSys(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSys::openFileSys(string name) {
	int ret = -1;
	int i;
	file = fopen(name.c_str(), "r+");
	if (file != NULL) {
		boot = new BootRecord();
		readBootRecord(boot);

		if ((boot->clusterSize < (MIN_CLUSTER_SIZE * 1024) 
			|| boot->clusterSize > (MAX_CLUSTER_SIZE * 1024)
			|| boot->size < (MIN_FILE_SIZE * 1024 * 1024)
			|| boot->size > (MAX_FILE_SIZE * 1024 * 1024)
			|| boot->size < boot->clusterSize)) {
			ret = -1;
		} else {
			sysName = name;
			entriesPerTable = (boot->clusterSize)/DT_ENTRY_SIZE;
			numClusters = (boot->size)/(boot->clusterSize);
			fileAllocationTable = new int[numClusters];
			directoryTable.resize(entriesPerTable);

			readFAT(fileAllocationTable, boot->FAT);
			readDirectoryTable(&directoryTable, boot->rootDir);

			printInfo();
			ret = 0; 
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
callq 0x3110
movq %rax, %rdi
leaq 0x8733(%rip), %rsi      # 0xc030
callq 0x3360
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
je 0x3a5d
movl $0x10, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x3170
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
movq %rax, 0x58(%rdi)
movq 0x58(%rdi), %rsi
callq 0x3a70
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x2000, (%rax)         # imm = 0x2000
jb 0x399f
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x4000, (%rax)         # imm = 0x4000
ja 0x399f
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x500000, 0x4(%rax)    # imm = 0x500000
jb 0x399f
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x3200000, 0x4(%rax)   # imm = 0x3200000
ja 0x399f
movq -0x20(%rbp), %rcx
movq 0x58(%rcx), %rax
movl 0x4(%rax), %eax
movq 0x58(%rcx), %rcx
cmpl (%rcx), %eax
jae 0x39ab
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a5b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3050
movq -0x20(%rbp), %rcx
movq 0x58(%rcx), %rax
movl (%rax), %eax
shrl $0x7, %eax
movl %eax, 0x2c(%rcx)
movq 0x58(%rcx), %rax
movl 0x4(%rax), %eax
movq 0x58(%rcx), %rcx
xorl %edx, %edx
divl (%rcx)
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movslq 0x30(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x2c(%rax), %rsi
callq 0x6980
movq -0x20(%rbp), %rdi
movq 0x38(%rdi), %rsi
movq 0x58(%rdi), %rax
movl 0xc(%rax), %edx
callq 0x3ac0
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq 0x58(%rdi), %rax
movl 0x8(%rax), %edx
callq 0x3b30
movq -0x20(%rbp), %rdi
callq 0x3c00
movl $0x0, -0x14(%rbp)
jmp 0x3a5d
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::readFAT(int*, int)
void FileSys::readFAT(int *fat, int cluster) {
	int offset =  boot->clusterSize * cluster;
	if (offset < boot->size) {
		fseek(file, offset, SEEK_SET);
		fread(fat, numClusters * sizeof(int), 1, file);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x58(%rcx), %rax
movl (%rax), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq 0x58(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jae 0x3b25
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3330
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq 0x30(%rax), %rsi
shlq $0x2, %rsi
movq 0x20(%rax), %rcx
movl $0x1, %edx
callq 0x3460
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::readDirectoryTable(std::vector<DirectoryTableEntry, std::allocator<DirectoryTableEntry>>*, int)
int FileSys::readDirectoryTable(vector<DirectoryTableEntry> *table, int cluster) {
	int offset;
	int i = 0;
	int j = 0;
	int clusterSize = boot->clusterSize;

	do {
		table->resize((i + 1)*entriesPerTable);
		offset =  clusterSize * cluster;
		fseek(file, offset, SEEK_SET);
		fread(&((*table)[i * entriesPerTable]), 128, entriesPerTable, file);
		cluster = fileAllocationTable[cluster];
		i++;
	} while(cluster  != 0xFFFF);
	return table->size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq 0x58(%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
imull 0x2c(%rcx), %eax
movslq %eax, %rsi
callq 0x6980
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x20(%rax), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3330
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull 0x2c(%rcx), %eax
movslq %eax, %rsi
callq 0x6a10
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq 0x2c(%rax), %rdx
movq 0x20(%rax), %rcx
movl $0x80, %esi
callq 0x3460
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jne 0x3b62
movq -0x10(%rbp), %rdi
callq 0x6b80
addq $0x30, %rsp
popq %rbp
retq
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::writeFAT(int*, int)
void FileSys::writeFAT(int *fat, int cluster) {
	int offset =  boot->clusterSize * cluster;
	if (offset < boot->size) {
		fseek(file, offset, SEEK_SET);
		fwrite(fat, numClusters * sizeof(int), 1, file);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x58(%rcx), %rax
movl (%rax), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq 0x58(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jae 0x3f65
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3330
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq 0x30(%rax), %rsi
shlq $0x2, %rsi
movq 0x20(%rax), %rcx
movl $0x1, %edx
callq 0x3590
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::writeDirectoryTable(std::vector<DirectoryTableEntry, std::allocator<DirectoryTableEntry>>*, int)
void FileSys::writeDirectoryTable(vector<DirectoryTableEntry> *table, int cluster) {
	int offset;
	int i = 0;
	int j = 0;
	int clusterSize = boot->clusterSize;

	do {
		offset =  clusterSize * cluster;
		fseek(file, offset, SEEK_SET);

		fwrite(&((*table)[i * entriesPerTable]), 128, entriesPerTable, file);
		cluster = fileAllocationTable[cluster];
		i++;
	} while(cluster != 0xFFFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq 0x58(%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x20(%rax), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3330
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull 0x2c(%rcx), %eax
movslq %eax, %rsi
callq 0x6a10
movq %rax, %rdi
movq -0x30(%rbp), %rax
movslq 0x2c(%rax), %rdx
movq 0x20(%rax), %rcx
movl $0x80, %esi
callq 0x3590
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jne 0x3fa2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::findUsedClusterCount()
int FileSys::findUsedClusterCount() {
	int i;
	usedClusters = 0;

	for (i = 0; i < numClusters; i++) {
		if (fileAllocationTable[i] != 0x0000) {
			usedClusters++;
		}
	}

	return usedClusters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x28(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x4076
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x4069
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x406b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x403e
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
popq %rbp
retq
nop
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::getDirectoryFileCount(std::vector<DirectoryTableEntry, std::allocator<DirectoryTableEntry>>)
int FileSys::getDirectoryFileCount(vector<DirectoryTableEntry> table) {
	int ret = 0;
	int i;
	for (i = 0; i < table.size(); i++) {
		if (table[i].name[0] != (char)0x00 && table[i].name[0] != (char)0xFF) {
			ret++;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6b80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x466f
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4662
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movsbl (%rax), %eax
cmpl $-0x1, %eax
je 0x4662
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4664
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4612
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::findNextFreeCluster()
int FileSys::findNextFreeCluster() {
	int i;
	int ret = 0xFFFF;

	for (i = 1; i < numClusters && ret == 0xFFFF; i++) {
		if (fileAllocationTable[i] == 0x0000) {
			ret = i;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x30(%rdx), %ecx
movb %al, -0x19(%rbp)
jge 0x46bc
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x46c5
jmp 0x46ea
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x46dd
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x46df
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x469e
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::findIndexForFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSys::findIndexForFile(string name) {
	int i;
	int index = -1;
	for (i = 0; i < directoryTable.size() && index == -1; i++) {
		if (directoryTable[i].name == name) {
			index = i;
		}
	}
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x40, %rdi
callq 0x6b80
movq -0x38(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jae 0x474a
cmpl $-0x1, -0x18(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4753
jmp 0x4789
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6a10
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x6ba0
testb $0x1, %al
jne 0x4776
jmp 0x477c
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x477e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x471a
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::removeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSys::removeFile(string name) {
	int ret = 0;
	int i;
	int cluster;
	int oldCluster;
	int index = -1;
	for (i = directoryTable.size()-1; i >= 0 && (name == "*" || index == -1); i--) {
		if (directoryTable[i].name == name ||
			(name == "*" && (directoryTable[i].name[0] != (char)0x00 
					&& directoryTable[i].name[0] != (char)0xFF))) {
			index = i;
			if (removeFile(index) == -1) {
				ret = -1;
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
addq $0x40, %rdi
callq 0x6b80
subq $0x1, %rax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x39(%rbp)
jl 0x5ae1
movq -0x38(%rbp), %rdi
leaq 0x657b(%rip), %rsi      # 0xc03b
callq 0x6c90
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x3a(%rbp)
jne 0x5adb
cmpl $-0x1, -0x24(%rbp)
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5aed
jmp 0x5b86
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x6ba0
testb $0x1, %al
jne 0x5b56
movq -0x38(%rbp), %rdi
leaq 0x6522(%rip), %rsi      # 0xc03b
callq 0x6c90
testb $0x1, %al
jne 0x5b24
jmp 0x5b76
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5b76
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movsbl (%rax), %eax
cmpl $-0x1, %eax
je 0x5b76
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0x5b90
cmpl $-0x1, %eax
jne 0x5b74
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x5b76
jmp 0x5b78
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5aaa
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::removeFile(int)
int FileSys::removeFile(int index) {
	int ret = -1;
	int cluster;
	int oldCluster;
	if (index != -1) {
		directoryTable[index].name[0] = 0xFF;

		cluster = directoryTable[index].index;
		do {
			oldCluster = cluster;
			cluster = fileAllocationTable[oldCluster];
			fileAllocationTable[oldCluster] = 0x0000;
		} while(cluster != 0xFFFF);

		directoryTable.erase(directoryTable.begin() + index);
		writeFAT(fileAllocationTable, boot->FAT);
		writeDirectoryTable(&directoryTable, boot->rootDir);
		ret = 0;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
cmpl $-0x1, -0xc(%rbp)
je 0x5c90
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6a10
movq -0x40(%rbp), %rdi
movb $-0x1, (%rax)
addq $0x40, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6a10
movl 0x70(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x38(%rax), %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x14(%rbp)
movq 0x38(%rax), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jne 0x5be3
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x48(%rbp)
addq $0x40, %rdi
callq 0x6d30
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x6d60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6da0
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6cc0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq 0x38(%rdi), %rsi
movq 0x58(%rdi), %rax
movl 0xc(%rax), %edx
callq 0x3f00
movq -0x40(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq 0x58(%rdi), %rax
movl 0x8(%rax), %edx
callq 0x3f70
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::moveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
int FileSys::moveFile(string source, string dest, 
						bool sourceInFileSys, bool destInFileSys) {
	int ret = -1;
	if (source != dest) {
		ret = copyFile(source, dest, sourceInFileSys, destInFileSys);
		if (ret >= 0) {
			if (sourceInFileSys) {
				ret = removeFile(source);
			} else {
				ret = remove(source.c_str());
			}
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xa8(%rbp)
movq %rsi, %rax
movq -0xa8(%rbp), %rsi
movq %rax, -0xa0(%rbp)
movq %rdi, %rdx
movq -0xa0(%rbp), %rdi
movb %r8b, %al
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
callq 0x6c60
testb $0x1, %al
jne 0x5d07
jmp 0x5e33
movq -0xa0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3120
movq -0xa8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3120
jmp 0x5d29
movq -0x98(%rbp), %rdi
movzbl -0x1a(%rbp), %r8d
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4ae0
movl %eax, -0xac(%rbp)
jmp 0x5d55
movl -0xac(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
cmpl $0x0, -0x20(%rbp)
jl 0x5e31
testb $0x1, -0x19(%rbp)
je 0x5e18
movq -0xa0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3120
movq -0x98(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x5a70
movl %eax, -0xb0(%rbp)
jmp 0x5db9
movl -0xb0(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3180
jmp 0x5e2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5df3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x5e3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3180
jmp 0x5e3f
movq -0xa0(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3560
movl %eax, -0x20(%rbp)
jmp 0x5e31
jmp 0x5e33
movl -0x20(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3530
nopl (%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::printFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSys::printFile(string name) {
	int ret = -1;
	int index;
	int cluster;
	int leftOver;
	int offset;
	int clusterSize = boot->clusterSize;
	void *clusterData;

	index = findIndexForFile(name);
	if (index != -1) {
		clusterData = malloc(clusterSize);
		cluster = directoryTable[index].index;
		leftOver = directoryTable[index].size % clusterSize;

		while (fileAllocationTable[cluster] != 0xFFFF) {
			offset = clusterSize * cluster;
			fseek(file, offset, SEEK_SET);
			fread(clusterData, clusterSize, 1, file);
			cout << (char*)clusterData;
			cluster = fileAllocationTable[cluster];
		}
		offset = clusterSize * cluster;
		fseek(file, offset, SEEK_SET);
		while (leftOver > 0) {
			cout << (char)fgetc(file);
			leftOver--;
		}

		free(clusterData);
		ret = 0;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq 0x58(%rax), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3120
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x46f0
movl %eax, -0x60(%rbp)
jmp 0x5e97
movl -0x60(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3180
cmpl $-0x1, -0x18(%rbp)
je 0x5fd1
movslq -0x28(%rbp), %rdi
callq 0x3400
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movq -0x70(%rbp), %rdi
movl 0x70(%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x40, %rdi
movslq -0x18(%rbp), %rsi
callq 0x6a10
movl 0x74(%rax), %eax
xorl %edx, %edx
divl -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x70(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0xffff, (%rax,%rcx,4)  # imm = 0xFFFF
je 0x5f77
movq -0x70(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x1c(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x20(%rax), %rdi
movslq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x3330
movq -0x70(%rbp), %rax
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
movq 0x20(%rax), %rcx
movl $0x1, %edx
callq 0x3460
movq -0x30(%rbp), %rsi
movq 0xa089(%rip), %rdi      # 0xffd0
callq 0x3290
movq -0x70(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ef0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3180
jmp 0x5fda
movq -0x70(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x1c(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x20(%rax), %rdi
movslq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x3330
cmpl $0x0, -0x20(%rbp)
jle 0x5fc1
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x34c0
movq 0xa022(%rip), %rdi      # 0xffd0
movsbl %al, %esi
callq 0x3350
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5f94
movq -0x30(%rbp), %rdi
callq 0x3370
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: emr4378[P]FAT-File-System/FileSys.cpp
// Function: FileSys::printInfo(int, std::vector<DirectoryTableEntry, std::allocator<DirectoryTableEntry>>*)
void FileSys::printInfo(int width, vector<DirectoryTableEntry> *table) {
	printFAT(width);
	showStructure();
	if (table != NULL) {
		printDirectoryTable(*table);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
callq 0x64f0
movq -0x48(%rbp), %rdi
callq 0x5ff0
cmpq $0x0, -0x18(%rbp)
je 0x64d5
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6a30
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x4080
jmp 0x64b3
leaq -0x30(%rbp), %rdi
callq 0x6b20
jmp 0x64d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6b20
jmp 0x64db
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: emr4378[P]FAT-File-System/Shell.cpp
// Function: Shell::checkIfExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Shell::checkIfExists(string path) {
	struct stat info;
	bool ret;
	
	if ( stat(path.c_str(), &info) < 0 ) {
		ret = false;
	} else {
		ret = true;
	}
	
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3110
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3240
cmpl $0x0, %eax
jge 0x9256
movb $0x0, -0xa1(%rbp)
jmp 0x925d
movb $0x1, -0xa1(%rbp)
movb -0xa1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: emr4378[P]FAT-File-System/Shell.cpp
// Function: Shell::prompt()
void Shell::prompt() {
	char input[256];
	do {
		cout << "os1shell->";
		cin.getline(input, 256);
		runCommand(input);
		
	} while (!cin.eof());
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq 0x685f(%rip), %rdi      # 0xffd0
leaq 0x2a83(%rip), %rsi      # 0xc1fb
callq 0x3290
movq 0x685c(%rip), %rdi      # 0xffe0
leaq -0x110(%rbp), %rsi
movq %rsi, -0x160(%rbp)
movl $0x100, %edx            # imm = 0x100
callq 0x30b0
leaq -0x131(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x3540
movq -0x160(%rbp), %rsi
movq -0x158(%rbp), %rdx
leaq -0x130(%rbp), %rdi
callq 0x6e60
jmp 0x97cb
movq -0x150(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x9890
jmp 0x97e0
leaq -0x130(%rbp), %rdi
callq 0x3180
leaq -0x131(%rbp), %rdi
callq 0x3300
movq 0x67e1(%rip), %rax      # 0xffe0
movq (%rax), %rax
movq 0x67d7(%rip), %rdi      # 0xffe0
addq -0x18(%rax), %rdi
callq 0x3570
xorb $-0x1, %al
testb $0x1, %al
jne 0x976a
movq 0x67ad(%rip), %rdi      # 0xffd0
movq 0x6796(%rip), %rsi      # 0xffc0
callq 0x32e0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x986a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x3180
leaq -0x131(%rbp), %rdi
callq 0x3300
movq -0x140(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: emr4378[P]FAT-File-System/Shell.cpp
// Function: Shell::getTokens(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Shell::getTokens(string orig, string delims, string tokens[]) {
	int i;
	int j;
	int lastPos;
	int c;
	string origDup;
	string token;

	origDup = orig;
	j = 0;
	lastPos = 0;
	i = 0;

	while ( ( j = origDup.find_first_of(delims, lastPos) ) != -1 ) {
		token = origDup.substr(lastPos, j-lastPos);
		if (!token.empty()) {
			tokens[i] = token;
			i++;
		}
		lastPos = j + 1;
	}
	token = origDup.substr(lastPos);
	tokens[i] = token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3430
leaq -0x70(%rbp), %rdi
callq 0x3430
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x3050
jmp 0xa047
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0xd8(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x3230
movl %eax, -0x28(%rbp)
cmpl $-0x1, %eax
je 0xa11b
movslq -0x2c(%rbp), %rdx
movl %edx, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x32d0
jmp 0xa09c
leaq -0x70(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3390
leaq -0xa0(%rbp), %rdi
callq 0x3180
leaq -0x70(%rbp), %rdi
callq 0x3510
testb $0x1, %al
jne 0xa10d
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
callq 0x3050
jmp 0xa0df
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa10d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x50(%rbp), %rdi
callq 0x3180
jmp 0xa19a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa05c
movslq -0x2c(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq $-0x1, %rcx
callq 0x32d0
jmp 0xa138
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0xc0(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
callq 0x3390
movq -0xe8(%rbp), %rdi
callq 0x3180
movq -0xe0(%rbp), %rsi
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3050
jmp 0xa17f
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x50(%rbp), %rdi
callq 0x3180
addq $0xf0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: emr4378[P]FAT-File-System/Shell.cpp
// Function: Shell::runRealCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
int Shell::runRealCommand(string tokens[]) {
	int ret = -1;
	int i;
	char* args[256];
	cout << "Command: ";
	i = 0;
	while (!tokens[i].empty()) {
		args[i] = (char*)malloc(sizeof(char)*tokens[i].length());
		strcpy(args[i], tokens[i].c_str());
		cout << args[i] << " ";
		i++;
	}
	args[i] = NULL;
	cout << endl;

	pid_t pID = fork();
	if (pID == 0) {
		//success,  Child stuffs
		execvp(*args, args);
		cout << "Not a valid command" << endl;
		exit(0);
	} else if (pID < 0) {
		//failure :(
		exit(-1);
	} else {
		//parent stuffs
		int status;
		pid_t tpid;
		do {
			tpid = wait(&status);
		} while (tpid != pID);

		while (i>0) {
			free(args[i]);
			i--;
		}

		ret = 0;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp            # imm = 0x840
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq 0x4c8f(%rip), %rdi      # 0xffd0
leaq 0xf15(%rip), %rsi       # 0xc25d
callq 0x3290
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3510
xorb $-0x1, %al
testb $0x1, %al
jne 0xb373
jmp 0xb40d
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3470
movq %rax, %rdi
shlq $0x0, %rdi
callq 0x3400
movq %rax, %rcx
movslq -0x18(%rbp), %rax
movq %rcx, -0x820(%rbp,%rax,8)
movslq -0x18(%rbp), %rax
movq -0x820(%rbp,%rax,8), %rax
movq %rax, -0x838(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3110
movq -0x838(%rbp), %rdi
movq %rax, %rsi
callq 0x3260
movslq -0x18(%rbp), %rax
movq -0x820(%rbp,%rax,8), %rsi
movq 0x4be5(%rip), %rdi      # 0xffd0
callq 0x3290
movq %rax, %rdi
leaq 0xda4(%rip), %rsi       # 0xc19e
callq 0x3290
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb354
movslq -0x18(%rbp), %rax
movq $0x0, -0x820(%rbp,%rax,8)
movq 0x4bac(%rip), %rdi      # 0xffd0
movq 0x4b95(%rip), %rsi      # 0xffc0
callq 0x32e0
callq 0x3080
movl %eax, -0x824(%rbp)
cmpl $0x0, -0x824(%rbp)
jne 0xb480
movq -0x820(%rbp), %rdi
leaq -0x820(%rbp), %rsi
callq 0x31c0
movq 0x4b72(%rip), %rdi      # 0xffd0
leaq 0xe02(%rip), %rsi       # 0xc267
callq 0x3290
movq %rax, %rdi
movq 0x4b4c(%rip), %rsi      # 0xffc0
callq 0x32e0
xorl %edi, %edi
callq 0x3380
cmpl $0x0, -0x824(%rbp)
jge 0xb493
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
jmp 0xb495
leaq -0x828(%rbp), %rdi
callq 0x33b0
movl %eax, -0x82c(%rbp)
movl -0x82c(%rbp), %eax
cmpl -0x824(%rbp), %eax
jne 0xb495
jmp 0xb4b7
cmpl $0x0, -0x18(%rbp)
jle 0xb4d9
movslq -0x18(%rbp), %rax
movq -0x820(%rbp,%rax,8), %rdi
callq 0x3370
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb4b7
movl $0x0, -0x14(%rbp)
jmp 0xb4e2
movl -0x14(%rbp), %eax
addq $0x840, %rsp            # imm = 0x840
popq %rbp
retq
nop
// File: emr4378[P]FAT-File-System/Shell.cpp
// Function: Shell::checkIfDirExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Shell::checkIfDirExists(string path) {
	bool ret = false;
	if (opendir(path.c_str()) != NULL) {
		ret = true;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3110
movq %rax, %rdi
callq 0x3480
cmpq $0x0, %rax
je 0xb526
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: moyix[P]pandalog_taint_parser/label_tcn.cpp
// Function: progress_func(void*)
void *progress_func(void *arg) {
    while (processed != total_chunks) {
        int p = processed.load();
        printf("\r%4d / %4d chunks processed (%3.2f%%), max_tcn=%u.", p, total_chunks, 100*((float)p/total_chunks), max_tcn);
        fflush(stdout);
        usleep(500000);
    }
    printf("\n");
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
leaq 0x3e6ed(%rip), %rdi     # 0x45710
callq 0x7db0
cmpl 0x3e6ea(%rip), %eax     # 0x45718
je 0x710a
leaq 0x3e6d5(%rip), %rax     # 0x45710
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x9be0
movl %eax, -0x28(%rbp)
jmp 0x7060
movl -0x28(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
decl %eax
subl $0x2, %eax
jb 0x708a
jmp 0x7075
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x7095
jmp 0x707f
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x70a8
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x70a8
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x70a8
movq %rax, %rdi
callq 0x8440
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
movl 0x3e661(%rip), %edx     # 0x45718
cvtsi2ssl -0x24(%rbp), %xmm1
cvtsi2ssl 0x3e654(%rip), %xmm0 # 0x45718
divss %xmm0, %xmm1
movss 0x2af48(%rip), %xmm0    # 0x32018
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movl 0x3e636(%rip), %ecx     # 0x45714
leaq 0x2afe7(%rip), %rdi     # 0x320cc
movb $0x1, %al
callq 0x6040
movq 0x3dea5(%rip), %rax     # 0x44f98
movq (%rax), %rdi
callq 0x63e0
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x64b0
jmp 0x701c
leaq 0x2b040(%rip), %rdi     # 0x32151
movb $0x0, %al
callq 0x6040
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: marxn[P]pupp/3rdparty/gmp/gen-fib.c
// Function: header
void
header (int numb_bits)
{
  printf ("/* This file generated by gen-fib.c - DO NOT EDIT. */\n");
  printf ("\n");
  printf ("#if GMP_NUMB_BITS != %d\n", numb_bits);
  printf ("Error, error, this data is for %d bits\n", numb_bits);
  printf ("#endif\n");
  printf ("\n");
  printf ("#define FIB_TABLE_LIMIT         %d\n", fib_limit);
  printf ("#define FIB_TABLE_LUCNUM_LIMIT  %d\n", luc_limit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x219a(%rip), %rdi      # 0xdb8c
movb $0x0, %al
callq 0x1060
leaq 0x227b(%rip), %rdi      # 0xdc7b
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %esi
leaq 0x21b2(%rip), %rdi      # 0xdbc3
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %esi
leaq 0x21ba(%rip), %rdi      # 0xdbdc
movb $0x0, %al
callq 0x1060
leaq 0x21d4(%rip), %rdi      # 0xdc04
movb $0x0, %al
callq 0x1060
leaq 0x223d(%rip), %rdi      # 0xdc7b
movb $0x0, %al
callq 0x1060
movl 0x6671(%rip), %esi      # 0x120bc
leaq 0x21ba(%rip), %rdi      # 0xdc0c
movb $0x0, %al
callq 0x1060
movl 0x6661(%rip), %esi      # 0x120c0
leaq 0x21ca(%rip), %rdi      # 0xdc30
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-fib.c
// Function: table
void
table (int numb_bits)
{
  int  i;

  printf ("/* This file generated by gen-fib.c - DO NOT EDIT. */\n");
  printf ("\n");
  printf ("#include \"gmp.h\"\n");
  printf ("#include \"gmp-impl.h\"\n");
  printf ("\n");
  printf ("#if GMP_NUMB_BITS != %d\n", numb_bits);
  printf ("Error, error, this data is for %d bits\n", numb_bits);
  printf ("#endif\n");
  printf ("\n");
  printf ("const mp_limb_t\n");
  printf ("__gmp_fib_table[FIB_TABLE_LIMIT+2] = {\n");

  for (i = 0; i < fnum; i++)
    {
      printf ("  CNST_LIMB (0x");
      mpz_out_str (stdout, 16, f[i]);
      printf ("),  /* %d */\n", i-1);
    }
  printf ("};\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x20fa(%rip), %rdi      # 0xdb8c
movb $0x0, %al
callq 0x1060
leaq 0x21db(%rip), %rdi      # 0xdc7b
movb $0x0, %al
callq 0x1060
leaq 0x21a6(%rip), %rdi      # 0xdc54
movb $0x0, %al
callq 0x1060
leaq 0x21aa(%rip), %rdi      # 0xdc66
movb $0x0, %al
callq 0x1060
leaq 0x21b1(%rip), %rdi      # 0xdc7b
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %esi
leaq 0x20e8(%rip), %rdi      # 0xdbc3
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %esi
leaq 0x20f0(%rip), %rdi      # 0xdbdc
movb $0x0, %al
callq 0x1060
leaq 0x210a(%rip), %rdi      # 0xdc04
movb $0x0, %al
callq 0x1060
leaq 0x2173(%rip), %rdi      # 0xdc7b
movb $0x0, %al
callq 0x1060
leaq 0x2167(%rip), %rdi      # 0xdc7d
movb $0x0, %al
callq 0x1060
leaq 0x216a(%rip), %rdi      # 0xdc8e
movb $0x0, %al
callq 0x1060
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x657d(%rip), %eax      # 0x120b8
jge 0xbb90
leaq 0x2172(%rip), %rdi      # 0xdcb6
movb $0x0, %al
callq 0x1060
movq 0x6486(%rip), %rax      # 0x11fd8
movq (%rax), %rdi
movq 0x6554(%rip), %rdx      # 0x120b0
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movl $0x10, %esi
callq 0xace0
movl -0x8(%rbp), %esi
subl $0x1, %esi
leaq 0x2148(%rip), %rdi      # 0xdcc6
movb $0x0, %al
callq 0x1060
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbb32
leaq 0x213d(%rip), %rdi      # 0xdcd4
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-fib.c
// Function: main
int
main (int argc, char *argv[])
{
  int  limb_bits, nail_bits, numb_bits;

  if (argc != 4)
    {
      fprintf (stderr, "Usage: gen-fib <header|table> <limbbits> <nailbits>\n");
      exit (1);
    }

  limb_bits = atoi (argv[2]);
  nail_bits = atoi (argv[3]);

  if (limb_bits <= 0
      || nail_bits < 0
      || nail_bits >= limb_bits)
    {
      fprintf (stderr, "Invalid limb/nail bits: %d %d\n",
               limb_bits, nail_bits);
      exit (1);
    }
  numb_bits = limb_bits - nail_bits;

  generate (numb_bits);

  if (strcmp (argv[1], "header") == 0)
    header (numb_bits);
  else if (strcmp (argv[1], "table") == 0)
    table (numb_bits);
  else
    {
      fprintf (stderr, "Invalid header/table choice: %s\n", argv[1]);
      exit (1);
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0xbbee
movq 0x6425(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x20fb(%rip), %rsi      # 0xdcd8
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10c0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xbc22
cmpl $0x0, -0x18(%rbp)
jl 0xbc22
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0xbc4a
movq 0x63cf(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x20d4(%rip), %rsi      # 0xdd0d
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10d0
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xb810
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x20c2(%rip), %rsi      # 0xdd2c
callq 0x1080
cmpl $0x0, %eax
jne 0xbc7e
movl -0x1c(%rbp), %edi
callq 0xb9e0
jmp 0xbccd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x20a6(%rip), %rsi      # 0xdd33
callq 0x1080
cmpl $0x0, %eax
jne 0xbca1
movl -0x1c(%rbp), %edi
callq 0xba80
jmp 0xbccb
movq 0x6350(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x207f(%rip), %rsi      # 0xdd39
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10d0
jmp 0xbccd
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: snesic[P]stochastic_thin_films/film.cpp
// Function: film::set_h2_3()
void film::set_h2_3()
{
    for(int i=0;i<L;i++)
    {
        y[i]=h[i];
        h2[i]=h[i]*h[i];
        h3[i]=h[i]*h2[i];
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x47b6
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x30(%rax), %rcx
movslq -0xc(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x50(%rax), %rcx
movslq -0xc(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x50(%rax), %rcx
movslq -0xc(%rbp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4737
popq %rbp
retq
nopl (%rax,%rax)
// File: snesic[P]stochastic_thin_films/film.cpp
// Function: film::create_noise(long*)
void film::create_noise(long *inic)
{
    double dht=sqrt(dt*sigma);
    static boost::variate_generator<boost::mt19937, boost::normal_distribution<> >
    generator(boost::mt19937(time(0)),boost::normal_distribution<>());

    
    for(int i=0;i<L;i++)
        noise[i+1]=dht/dx * sqrt(h3[i]/dx) * generator();
    
    // Boundary conditions for the noise:
    noise[0]=0;
    noise[1]=0;
    noise[2]=0;
    noise[L+1]=0;
    noise[L]=0;
    noise[L-1]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1400, %rsp           # imm = 0x1400
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa28(%rbp)
movsd 0x10(%rax), %xmm0
mulsd 0xa0(%rax), %xmm0
callq 0x31d0
movsd %xmm0, -0x18(%rbp)
cmpb $0x0, 0xb3f4(%rip)      # 0xfc80
jne 0x493f
leaq 0xb3e7(%rip), %rdi      # 0xfc80
callq 0x3460
cmpl $0x0, %eax
je 0x493f
xorl %eax, %eax
movl %eax, %edi
callq 0x3250
movl %eax, -0x9e4(%rbp)
leaq -0x9e0(%rbp), %rdi
leaq -0x9e4(%rbp), %rsi
callq 0x5230
jmp 0x48cb
movq $0x0, -0xa10(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0xa18(%rbp)
leaq -0xa08(%rbp), %rdi
leaq -0xa10(%rbp), %rsi
leaq -0xa18(%rbp), %rdx
callq 0x5260
jmp 0x4903
movsd -0xa08(%rbp), %xmm0
movsd -0xa00(%rbp), %xmm1
movq %rsp, %rdi
movl $0x139, %ecx            # imm = 0x139
leaq -0x9e0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa97c(%rip), %rdi      # 0xf2a8
callq 0x52d0
jmp 0x4933
leaq 0xb346(%rip), %rdi      # 0xfc80
callq 0x3160
movl $0x0, -0xa1c(%rbp)
movq -0xa28(%rbp), %rcx
movl -0xa1c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x4a14
movq -0xa28(%rbp), %rax
movsd -0x18(%rbp), %xmm0
divsd 0x8(%rax), %xmm0
movsd %xmm0, -0xa38(%rbp)
movq 0x58(%rax), %rcx
movslq -0xa1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
divsd 0x8(%rax), %xmm0
callq 0x31d0
movaps %xmm0, %xmm1
movsd -0xa38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0xa30(%rbp)
leaq 0xa8f8(%rip), %rdi      # 0xf2a8
callq 0x5320
movq -0xa28(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0xa30(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq 0x70(%rax), %rax
movl -0xa1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xa1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa1c(%rbp)
jmp 0x4949
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x9f0(%rbp)
movl %eax, -0x9f4(%rbp)
leaq 0xb273(%rip), %rdi      # 0xfc80
callq 0x3150
jmp 0x4a81
movq -0xa28(%rbp), %rcx
movq 0x70(%rcx), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x70(%rcx), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x70(%rcx), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x70(%rcx), %rax
movl 0x20(%rcx), %edx
addl $0x1, %edx
movslq %edx, %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rdx,8)
movq 0x70(%rcx), %rax
movslq 0x20(%rcx), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rdx,8)
movq 0x70(%rcx), %rax
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x1400, %rsp           # imm = 0x1400
popq %rbp
retq
movq -0x9f0(%rbp), %rdi
callq 0x3420
nopl (%rax)