LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: massykezzoul[P]jeu-de-la-vie/main.cpp
// Function: main
int main(int argc, char const *argv[])
{
	// Initialisé le jeu selon les arguments donnée en paramétre
	Population jeu(argc,argv);
	jeu.init();
	/*
	jeu.affiche_matrice_bw();
	jeu.affiche_dynamique();

	jeu = jeu.next();

	jeu.affiche_matrice_bw();
	jeu.affiche_dynamique();

	jeu = jeu.next();

	jeu.affiche_matrice();
	jeu.affiche_dynamique();
	*/

	simulation(jeu);

	/* Mode Statistique à regler*/
	//fstream stat("vie.stat",ios::out | ios::app);
	//jeu.begin(stat);

	cout << endl << "############################# END OF PROG #############################" << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4320
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5420
jmp 0x9acc
leaq -0x50(%rbp), %rdi
callq 0x5f40
jmp 0x9ad7
movq 0x44f2(%rip), %rdi      # 0xdfd0
movq 0x44db(%rip), %rsi      # 0xdfc0
callq 0x3270
movq %rax, -0x70(%rbp)
jmp 0x9af0
movq -0x70(%rbp), %rdi
leaq 0xbed(%rip), %rsi       # 0xa6e8
callq 0x3250
movq %rax, -0x78(%rbp)
jmp 0x9b06
movq -0x78(%rbp), %rdi
movq 0x44af(%rip), %rsi      # 0xdfc0
callq 0x3270
jmp 0x9b18
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5230
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5230
movq -0x58(%rbp), %rdi
callq 0x33f0
// File: vividvilla[P]hackerrank/src/pairs.cpp
// Function: getPairs(std::vector<int, std::allocator<int>>, int)
int getPairs(vector<int> v, int K) {
    int p = 0;
    int N = v.size();
    set<int> ns;

    for (int i = 0; i < N; i++)
        ns.insert(v[i]);

    for (set<int>::iterator itr = ns.begin(); itr != ns.end(); itr++)
        if (ns.find(*itr + K) != ns.end())
            p++;

    return p;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movl $0x0, 0xb8(%rsp)
callq 0x1570
movl %eax, 0xb4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1590
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jge 0x133d
movq 0x20(%rsp), %rdi
movslq 0x7c(%rsp), %rsi
callq 0x1600
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x15a0
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x12fe
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movb %al, 0x60(%rsp)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x12c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1740
jmp 0x1429
leaq 0x80(%rsp), %rdi
callq 0x1620
movq %rax, 0x50(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1670
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1650
testb $0x1, %al
jne 0x1379
jmp 0x1405
leaq 0x50(%rsp), %rdi
callq 0x16e0
movl (%rax), %eax
movl 0xbc(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x3c(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x16a0
movq %rax, 0x8(%rsp)
jmp 0x13ab
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1670
movq %rax, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1650
testb $0x1, %al
jne 0x13dc
jmp 0x13ed
movl 0xb8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb8(%rsp)
jmp 0x13ef
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x1700
movq %rax, 0x28(%rsp)
jmp 0x134f
movl 0xb8(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1740
movl 0x4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: vividvilla[P]hackerrank/src/pairs.cpp
// Function: main
int main() {
    int N, K, x;
    cin >> N >> K;

    vector<int> v;
    for (int i = 0; i < N; i++) {
        cin >> x;
        v.push_back(x);
    }

    cout << getPairs(v, K) << endl;

    return 0;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movq 0x5b8d(%rip), %rdi      # 0x6fe0
leaq 0x60(%rsp), %rsi
callq 0x1080
movq %rax, %rdi
leaq 0x5c(%rsp), %rsi
callq 0x1080
leaq 0x40(%rsp), %rdi
callq 0x1750
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x14cc
movq 0x5b53(%rip), %rdi      # 0x6fe0
leaq 0x58(%rsp), %rsi
callq 0x1080
jmp 0x1499
leaq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1760
jmp 0x14aa
jmp 0x14ac
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x147c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1556
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x17d0
jmp 0x14dd
movl 0x5c(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x1280
movl %eax, 0xc(%rsp)
jmp 0x14f1
movl 0xc(%rsp), %esi
movq 0x5ad4(%rip), %rdi      # 0x6fd0
callq 0x1120
movq %rax, (%rsp)
jmp 0x1507
movq (%rsp), %rdi
movq 0x5aae(%rip), %rsi      # 0x6fc0
callq 0x10e0
jmp 0x1519
leaq 0x10(%rsp), %rdi
callq 0x18d0
movl $0x0, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x18d0
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x18d0
leaq 0x40(%rsp), %rdi
callq 0x18d0
movq 0x30(%rsp), %rdi
callq 0x1130
nopw (%rax,%rax)
// File: giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::createFilePartialBWT()
int BCRexternalBWT::createFilePartialBWT() {
	//Creates one file (partial BWT) for each letter in the alphabet. From 1 to sizeAlpha-1
	static FILE *OutFileBWT;                  // output and input file BWT;
	char *filenameOut = new char[120];
	char *filename1 = new char[100];
	for (dataTypedimAlpha i = 0; i < sizeAlpha; i++) {
		sprintf (filename1, "bwt_%d", i);
		sprintf (filenameOut,"%s%s",filename1,ext);

		OutFileBWT = fopen(filenameOut, "wb");
		if (OutFileBWT==NULL) {
			std::cerr << "BWT file " << (unsigned int)i <<" : Error opening " << std::endl;
			exit (EXIT_FAILURE);
		}
		fclose(OutFileBWT);
	}
	delete [] filename1;
	delete [] filenameOut;



	//std::cerr << "\nPartial File name for input: " << fileOut <<" \n\n";
	return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x78, %edi
callq 0x3040
movq %rax, 0x28(%rsp)
movl $0x64, %edi
callq 0x3040
movq %rax, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x10(%rsp), %rcx
movzbl 0x1f(%rsp), %eax
movzbl 0x148(%rcx), %ecx
cmpl %ecx, %eax
jge 0x8d4b
movq 0x20(%rsp), %rdi
movzbl 0x1f(%rsp), %edx
leaq 0x10456(%rip), %rsi     # 0x190f6
movb $0x0, %al
callq 0x3060
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xff66(%rip), %rsi      # 0x18c1e
leaq 0xfeb2(%rip), %rcx      # 0x18b71
movb $0x0, %al
callq 0x3060
movq 0x28(%rsp), %rdi
leaq 0xfe0f(%rip), %rsi      # 0x18ae1
callq 0x32e0
movq %rax, 0x1763a(%rip)     # 0x20318
cmpq $0x0, 0x17632(%rip)     # 0x20318
jne 0x8d30
movq 0x17301(%rip), %rdi     # 0x1fff0
leaq 0x10069(%rip), %rsi     # 0x18d5f
callq 0x3260
movq %rax, %rdi
movzbl 0x1f(%rsp), %esi
callq 0x3350
movq %rax, %rdi
leaq 0xfc57(%rip), %rsi      # 0x18969
callq 0x3260
movq %rax, %rdi
movq 0x1729f(%rip), %rsi     # 0x1ffc0
callq 0x32a0
movl $0x1, %edi
callq 0x3300
movq 0x175e1(%rip), %rdi     # 0x20318
callq 0x3270
movb 0x1f(%rsp), %al
addb $0x1, %al
movb %al, 0x1f(%rsp)
jmp 0x8c76
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8d65
movq 0x8(%rsp), %rdi
callq 0x3330
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x8d7d
movq (%rsp), %rdi
callq 0x3330
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::openWriteFilePartialBWT_0()
FILE * BCRexternalBWT::openWriteFilePartialBWT_0( ) {
	static FILE *OutFileBWT;                  // output and input file BWT;
	char *filenameOut = new char[120];
	char *filename = new char[100];

	sprintf (filename, "bwt_%d",0);
	sprintf (filenameOut,"%s%s",filename,ext);

	OutFileBWT = fopen(filenameOut, "wb");
	if (OutFileBWT==NULL) {
		std::cerr << "BWT file $: Error opening: " << filenameOut << std::endl;
		exit (EXIT_FAILURE);
	}
	delete [] filenameOut;
	delete [] filename;

	return OutFileBWT;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x78, %edi
callq 0x3040
movq %rax, 0x18(%rsp)
movl $0x64, %edi
callq 0x3040
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x10333(%rip), %rsi     # 0x190f6
xorl %edx, %edx
movb $0x0, %al
callq 0x3060
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0xfe41(%rip), %rsi      # 0x18c1e
leaq 0xfd8d(%rip), %rcx      # 0x18b71
movb $0x0, %al
callq 0x3060
movq 0x18(%rsp), %rdi
leaq 0xfcea(%rip), %rsi      # 0x18ae1
callq 0x32e0
movq %rax, 0x1751d(%rip)     # 0x20320
cmpq $0x0, 0x17515(%rip)     # 0x20320
jne 0x8e46
movq 0x171dc(%rip), %rdi     # 0x1fff0
leaq 0x10296(%rip), %rsi     # 0x190b1
callq 0x3260
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x3260
movq %rax, %rdi
movq 0x17189(%rip), %rsi     # 0x1ffc0
callq 0x32a0
movl $0x1, %edi
callq 0x3300
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8e60
movq 0x8(%rsp), %rdi
callq 0x3330
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x8e78
movq (%rsp), %rdi
callq 0x3330
movq 0x174a1(%rip), %rax     # 0x20320
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::openFilePartialIn(unsigned char)
FILE * BCRexternalBWT::openFilePartialIn(dataTypedimAlpha currentPile) {
	static FILE *inFile;
	char *filenameIn = new char[120];
	char *filename = new char[100];
	sprintf (filename, "bwt_%d", currentPile);
	sprintf (filenameIn,"%s%s",filename,ext);
	inFile = fopen(filenameIn, "rb");
	if (inFile==NULL) {
		std::cerr << "openFilePartialIn: file currentPile=" << (unsigned int)currentPile << ": Error opening: " << filenameIn << std::endl;
		exit (EXIT_FAILURE);
	}
	delete [] filenameIn;
	delete [] filename;
	return inFile;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movl $0x78, %edi
callq 0x3040
movq %rax, 0x20(%rsp)
movl $0x64, %edi
callq 0x3040
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movzbl 0x2f(%rsp), %edx
leaq 0x101e7(%rip), %rsi     # 0x190f6
movb $0x0, %al
callq 0x3060
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xfcf7(%rip), %rsi      # 0x18c1e
leaq 0xfc43(%rip), %rcx      # 0x18b71
movb $0x0, %al
callq 0x3060
movq 0x20(%rsp), %rdi
leaq 0xfa1d(%rip), %rsi      # 0x1895e
callq 0x32e0
movq %rax, 0x173db(%rip)     # 0x20328
cmpq $0x0, 0x173d3(%rip)     # 0x20328
jne 0x8fac
movq 0x17092(%rip), %rdi     # 0x1fff0
leaq 0x10168(%rip), %rsi     # 0x190cd
callq 0x3260
movq %rax, %rdi
movzbl 0x2f(%rsp), %esi
callq 0x3350
movq %rax, %rdi
leaq 0x1013a(%rip), %rsi     # 0x190bb
callq 0x3260
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x3260
movq %rax, %rdi
movq 0x17023(%rip), %rsi     # 0x1ffc0
callq 0x32a0
movl $0x1, %edi
callq 0x3300
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x8fc6
movq 0x10(%rsp), %rdi
callq 0x3330
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x8fe0
movq 0x8(%rsp), %rdi
callq 0x3330
movq 0x17341(%rip), %rax     # 0x20328
addq $0x38, %rsp
retq
nopl (%rax)
// File: giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::openFilePartialOut(unsigned char)
FILE * BCRexternalBWT::openFilePartialOut(dataTypedimAlpha currentPile) {
	static FILE *outFile;
	char *filenameOut = new char[120];
	char *filename = new char[100];
	sprintf (filename, "new_bwt_%d", currentPile);
	sprintf (filenameOut,"%s%s",filename,ext);
	outFile = fopen(filenameOut, "ab");
	if (outFile==NULL) {
		std::cerr << "openFilePartialOut: file currentPile= " << (unsigned int)currentPile << ": Error opening: " << filenameOut << std::endl;
		exit (EXIT_FAILURE);
	}
	delete [] filenameOut;
	delete [] filename;
	return outFile;
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movl $0x78, %edi
callq 0x3040
movq %rax, 0x20(%rsp)
movl $0x64, %edi
callq 0x3040
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movzbl 0x2f(%rsp), %edx
leaq 0x10093(%rip), %rsi     # 0x190f2
movb $0x0, %al
callq 0x3060
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xfba7(%rip), %rsi      # 0x18c1e
leaq 0xfaf3(%rip), %rcx      # 0x18b71
movb $0x0, %al
callq 0x3060
movq 0x20(%rsp), %rdi
leaq 0x1006c(%rip), %rsi     # 0x190fd
callq 0x32e0
movq %rax, 0x17293(%rip)     # 0x20330
cmpq $0x0, 0x1728b(%rip)     # 0x20330
jne 0x90fc
movq 0x16f42(%rip), %rdi     # 0x1fff0
leaq 0x1004b(%rip), %rsi     # 0x19100
callq 0x3260
movq %rax, %rdi
movzbl 0x2f(%rsp), %esi
callq 0x3350
movq %rax, %rdi
leaq 0xffea(%rip), %rsi      # 0x190bb
callq 0x3260
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x3260
movq %rax, %rdi
movq 0x16ed3(%rip), %rsi     # 0x1ffc0
callq 0x32a0
movl $0x1, %edi
callq 0x3300
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x9116
movq 0x10(%rsp), %rdi
callq 0x3330
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x9130
movq 0x8(%rsp), %rdi
callq 0x3330
movq 0x171f9(%rip), %rax     # 0x20330
addq $0x38, %rsp
retq
nopl (%rax)
// File: giovannarosone[P]BCR_LCP_GSA/BCRexternalBWT.cpp
// Function: BCRexternalBWT::renameFilePartial(unsigned char)
int BCRexternalBWT::renameFilePartial(dataTypedimAlpha currentPile) {
	char *filenameOut = new char[120];
	char *filenameIn = new char[120];
	char *filename = new char[100];
	
	sprintf (filename, "bwt_%d", currentPile);
	sprintf (filenameIn,"%s%s",filename,ext);
	sprintf (filenameOut,"new_%s%s",filename,ext);
	//std::cerr << "Renaming - Filenames:" << filenameIn << "\t" <<filenameOut << std::endl;
	if (remove(filenameIn)!=0)
		std::cerr << filenameIn <<": Error deleting file" << std::endl;
	else
		if(rename(filenameOut,filenameIn))
			std::cerr << filenameOut <<": Error renaming " << std::endl;
	
	delete [] filenameIn;
	delete [] filename;
	delete [] filenameOut;
	return 1;
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movl $0x78, %edi
callq 0x3040
movq %rax, 0x30(%rsp)
movl $0x78, %edi
callq 0x3040
movq %rax, 0x28(%rsp)
movl $0x64, %edi
callq 0x3040
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movzbl 0x3f(%rsp), %edx
leaq 0xff68(%rip), %rsi      # 0x190f6
movb $0x0, %al
callq 0x3060
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xfa78(%rip), %rsi      # 0x18c1e
leaq 0xf9c4(%rip), %rcx      # 0x18b71
movb $0x0, %al
callq 0x3060
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0xfa55(%rip), %rsi      # 0x18c1a
leaq 0xf9a5(%rip), %rcx      # 0x18b71
movb $0x0, %al
callq 0x3060
movq 0x28(%rsp), %rdi
callq 0x34c0
cmpl $0x0, %eax
je 0x9213
movq 0x28(%rsp), %rsi
movq 0x16e02(%rip), %rdi     # 0x1fff0
callq 0x3260
movq %rax, %rdi
leaq 0xff2a(%rip), %rsi      # 0x19127
callq 0x3260
movq %rax, %rdi
movq 0x16db4(%rip), %rsi     # 0x1ffc0
callq 0x32a0
jmp 0x9258
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3170
cmpl $0x0, %eax
je 0x9256
movq 0x30(%rsp), %rsi
movq 0x16dbd(%rip), %rdi     # 0x1fff0
callq 0x3260
movq %rax, %rdi
leaq 0xfefb(%rip), %rsi      # 0x1913d
callq 0x3260
movq %rax, %rdi
movq 0x16d6f(%rip), %rsi     # 0x1ffc0
callq 0x32a0
jmp 0x9258
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x9272
movq 0x18(%rsp), %rdi
callq 0x3330
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x928c
movq 0x10(%rsp), %rdi
callq 0x3330
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x92a6
movq 0x8(%rsp), %rdi
callq 0x3330
movl $0x1, %eax
addq $0x48, %rsp
retq
// File: giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::FloorLog2(unsigned long)
unsigned Tools::FloorLog2(ulong i)
{
    ulong b = 0;
    if (i == 0)
        return 0;
    while (i)
    { 
        b++; 
        i >>= 1; 
    }
    return b - 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xd000
movl $0x0, -0x4(%rsp)
jmp 0xd034
jmp 0xd002
cmpq $0x0, -0x10(%rsp)
je 0xd027
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shrq %rax
movq %rax, -0x10(%rsp)
jmp 0xd002
movq -0x18(%rsp), %rax
subq $0x1, %rax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::MakeTable()
unsigned * Tools::MakeTable()
{
    unsigned *table = new unsigned[512];
    for(unsigned i = 0; i < 9; i++)
    {
        if (i == 0)
           table[i] = 0;
        if (i >= 1 && i < (1 << 1 )) 
           table[i] = 1;
        if (i >= (1 << 1 ) && i < (1 << 2 ))
           table[i] = 2;
        if (i >= (1 << 2 ) && i < (1 << 3 ))
           table[i] = 3;
        if (i >= (1 << 3 ) && i < (1 << 4 ))
           table[i] = 4;
        if (i >= (1 << 4 ) && i < (1 << 5 ))
           table[i] = 5;
        if (i >= (1 << 5 ) && i < (1 << 6 ))
           table[i] = 6;
        if (i >= (1 << 6 ) && i < (1 << 7 ))
           table[i] = 6;
        if (i >= (1 << 7 ) && i < (1 << 8 ))
           table[i] = 7;
        if (i >= (1 << 8 ) && i < (1 << 9 ))
           table[i] = 8;
    }
        return table;
}

// Assembly:
subq $0x18, %rsp
movl $0x800, %edi            # imm = 0x800
callq 0x3040
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x9, 0xc(%rsp)
jae 0xd1ac
cmpl $0x0, 0xc(%rsp)
jne 0xd07d
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
cmpl $0x1, 0xc(%rsp)
jb 0xd09b
cmpl $0x2, 0xc(%rsp)
jae 0xd09b
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x1, (%rax,%rcx,4)
cmpl $0x2, 0xc(%rsp)
jb 0xd0b9
cmpl $0x4, 0xc(%rsp)
jae 0xd0b9
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x2, (%rax,%rcx,4)
cmpl $0x4, 0xc(%rsp)
jb 0xd0d7
cmpl $0x8, 0xc(%rsp)
jae 0xd0d7
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x3, (%rax,%rcx,4)
cmpl $0x8, 0xc(%rsp)
jb 0xd0f5
cmpl $0x10, 0xc(%rsp)
jae 0xd0f5
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x4, (%rax,%rcx,4)
cmpl $0x10, 0xc(%rsp)
jb 0xd113
cmpl $0x20, 0xc(%rsp)
jae 0xd113
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x5, (%rax,%rcx,4)
cmpl $0x20, 0xc(%rsp)
jb 0xd131
cmpl $0x40, 0xc(%rsp)
jae 0xd131
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x6, (%rax,%rcx,4)
cmpl $0x40, 0xc(%rsp)
jb 0xd152
cmpl $0x80, 0xc(%rsp)
jae 0xd152
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x6, (%rax,%rcx,4)
cmpl $0x80, 0xc(%rsp)
jb 0xd176
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
jae 0xd176
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x7, (%rax,%rcx,4)
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
jb 0xd19a
cmpl $0x200, 0xc(%rsp)       # imm = 0x200
jae 0xd19a
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x8, (%rax,%rcx,4)
jmp 0xd19c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd05b
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::FastFloorLog2(unsigned int)
unsigned Tools::FastFloorLog2(unsigned i)
{
    unsigned *table = MakeTable(); unsigned u;
    if (i >> 24)    u = 22 + table[ i >> 24] ;
    if (i >> 16)    u = 14 + table[ i >> 16] ;
    if (i >> 8)     u = 6 + table[ i >> 8] ;
    u =  table[i] - 1;
    delete [] table;
    return u;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
callq 0xd040
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %eax
shrl $0x18, %eax
cmpl $0x0, %eax
je 0xd1f6
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
shrl $0x18, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
addl $0x16, %eax
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
shrl $0x10, %eax
cmpl $0x0, %eax
je 0xd21a
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
shrl $0x10, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
addl $0xe, %eax
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
shrl $0x8, %eax
cmpl $0x0, %eax
je 0xd23e
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
shrl $0x8, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
addl $0x6, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xd26b
movq 0x8(%rsp), %rdi
callq 0x3330
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::CeilLog2(unsigned long)
unsigned Tools::CeilLog2(ulong i)
{
    unsigned j = FloorLog2(i);
    if ((ulong)(1lu << j) != i)
        return j + 1;
        
    return j;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xcfe0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
cmpq 0x8(%rsp), %rax
je 0xd2b9
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd2c1
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: giovannarosone[P]BCR_LCP_GSA/Tools.cpp
// Function: Tools::GetFileContents(char*, unsigned long)
uchar * Tools::GetFileContents(char *filename, ulong maxSize)
{
    std::ifstream::pos_type posSize;
    std::ifstream file ((char *)filename, std::ios::in|std::ios::binary|std::ios::ate);
    if (file.is_open())
    {
        posSize = file.tellg();
        ulong size = posSize;
        if (maxSize != 0 && size > maxSize)
            size = maxSize;
        char *memblock = new char [size + 1];
        file.seekg (0, std::ios::beg);
        file.read (memblock, size);
        memblock[size] = '\0';
        file.close();
	return (uchar *)memblock;
    }
    else
        return 0;
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x288(%rsp)
movq %rsi, 0x280(%rsp)
leaq 0x270(%rsp), %rdi
callq 0xd4a0
movq 0x288(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x8, %edi
movl $0x4, %esi
callq 0xd4d0
movl %eax, %edi
movl $0x2, %esi
callq 0xd4d0
movq 0x20(%rsp), %rsi
movl %eax, %edx
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x34e0
movq 0x28(%rsp), %rdi
callq 0x3410
movb %al, 0x33(%rsp)
jmp 0xd342
movb 0x33(%rsp), %al
testb $0x1, %al
jne 0xd34f
jmp 0xd45d
leaq 0x68(%rsp), %rdi
callq 0x3490
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xd365
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movups 0x48(%rsp), %xmm0
movaps %xmm0, 0x270(%rsp)
leaq 0x270(%rsp), %rdi
callq 0xd4f0
movq %rax, 0x8(%rsp)
jmp 0xd39a
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x280(%rsp)
je 0xd3ea
movq 0x40(%rsp), %rax
cmpq 0x280(%rsp), %rax
jbe 0xd3ea
movq 0x280(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xd3ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x30a0
jmp 0xd48b
movq 0x40(%rsp), %rdi
incq %rdi
callq 0x3040
movq %rax, (%rsp)
jmp 0xd3fd
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0x68(%rsp), %rdi
callq 0x3360
jmp 0xd416
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x3320
jmp 0xd42c
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movb $0x0, (%rax,%rcx)
leaq 0x68(%rsp), %rdi
callq 0x3080
jmp 0xd446
movq 0x38(%rsp), %rax
movq %rax, 0x290(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0xd471
movq $0x0, 0x290(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x30a0
movq 0x290(%rsp), %rax
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x60(%rsp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
nop
// File: giovannarosone[P]BCR_LCP_GSA/Sorting.cpp
// Function: cmpSortEl(sortElement, sortElement)
bool cmpSortEl (sortElement a,sortElement b) { 
	if (a.pileN == b.pileN)
		return (a.posN < b.posN);
	else
		return (a.pileN<b.pileN); 
}

// Assembly:
movq %rdi, -0x28(%rsp)
movq %rsi, -0x20(%rsp)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movzbl (%rdi), %eax
movzbl (%rsi), %ecx
cmpl %ecx, %eax
jne 0xd53b
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x8(%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0xd556
movq -0x20(%rsp), %rcx
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: giovannarosone[P]BCR_LCP_GSA/TransposeFasta.cpp
// Function: TransposeFasta::readln(char*, int, _IO_FILE*)
ulong TransposeFasta::readln(char* s, int n, FILE* iop) {

  register long c=0;
  register char* cs;
  register long z = 0; // count characters
  cs=s;
  while (--n > 0 && (c = getc(iop)) != EOF) {
	  //std::cerr << "n= " << n << " c= " << c << " ";
	  //printf ("%c\n", c);
	  if ((*cs++ = c) == '\n')
		break;
	z++;
  }
  if (c == EOF && z==0)
	  z = 0; // signify end of file
  *cs = '\0';
  return z;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rsp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jle 0x11285
movq 0x28(%rsp), %rdi
callq 0x30c0
cltq
movq %rax, 0x20(%rsp)
cmpq $-0x1, %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1128f
jmp 0x112c1
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x112b1
jmp 0x112c1
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x11253
cmpq $-0x1, 0x20(%rsp)
jne 0x112da
cmpq $0x0, 0x10(%rsp)
jne 0x112da
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: giovannarosone[P]BCR_LCP_GSA/Timer.cpp
// Function: Timer::Timer()
Timer::Timer(void)
{
    if (gettimeofday(&lastTime_, NULL) != 0)
        exit(-1);
    if (getrusage(RUSAGE_SELF, &lastUsage_) != 0)
        exit(-1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x130, %rdi            # imm = 0x130
xorl %eax, %eax
movl %eax, %esi
callq 0x3420
cmpl $0x0, %eax
je 0x174e2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3300
movq 0x8(%rsp), %rsi
addq $0x90, %rsi
xorl %edi, %edi
callq 0x3160
cmpl $0x0, %eax
je 0x17504
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3300
addq $0x18, %rsp
retq
nopl (%rax)
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo01::test_primitives()
void test_primitives()
{
	cout << "\ntest_primitives()..........\n";
	void *p1 = malloc(512);	//512 bytes
	free(p1);
	p1 = NULL;

	complex<int> *p2 = new complex<int>;	//one object
	delete p2;
	p2 = NULL;

	void *p3 = ::operator new(512);	//512 bytes
	::operator delete(p3);
	p3 = NULL;

//以下使用c++标准库提供的allocators.
//其接口虽有标准规范，但实现厂商并未完全遵守：下面三者形式略异
#ifdef _MSC_VER
	//以下两个函数都是non-static，定要通过object调用。以下分配3个ints
	int *p4 = allocator<int>().allocate(3, (int*)0);
	allocator<int>().deallocate(p4, 3);
#endif

#ifdef __BORLANDC__
	//以下两个函数都是non-static，定要通过object调用。以下分配3个ints
	int *p5 = allocator<int>().allocate(3);
	allocator<int>().deallocate(p5, 3);
#endif

#ifdef __GUNC__
	//以下兩函數都是 static，可通過全名調用之。以下分配 512 bytes.
	//void *p6 = alloc::allocate(512);
	//alloc::deallocate(p4, 512);

	//以下兩函數都是 non-static，定要通過 object 調用。以下分配 3 個 ints.    
	int *p7 = allocator<int>().alllocate(3);
	allocator<int>().deallocate(p7, 3);

	//以下兩函數都是 non-static，定要通過 object 調用。以下分配 3 個 ints.    
	void *p8 = __gun_cxx::__pool_alloc<int>().allocate(3);
	__gun_cxx::__pool_alloc<int>().deallocate(p8, 3);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x69f9(%rip), %rdi      # 0x8fd8
leaq 0x3a34(%rip), %rsi      # 0x601a
callq 0x2190
movl $0x200, %edi            # imm = 0x200
callq 0x2260
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2220
movq $0x0, -0x8(%rbp)
movl $0x8, %edi
callq 0x21a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x42c0
jmp 0x263b
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x265f
movq -0x40(%rbp), %rdi
movl $0x8, %esi
callq 0x21b0
movq $0x0, -0x10(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0x21a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2180
movq $0x0, -0x30(%rbp)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x21b0
movq -0x20(%rbp), %rdi
callq 0x2300
nop
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo04::Screen::operator new(unsigned long)
void *Screen::operator new(size_t size)
{
	Screen *p;
	if (!freeStore) {
		//linked list 是空的，所以获取一大块memory
		//以下调用的是global operator new
		size_t chunk = screenChunk*size;
		freeStore = p = reinterpret_cast<Screen *>(new char[chunk]);
		//将分配得来的一大块memory，当做linked list将小块小块串联起来
		for (; p != &freeStore[screenChunk-1]; ++p) {
			p->next = p+1;
		}
		p->next = NULL;
	}
	p = freeStore;
	freeStore = freeStore->next;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x658c(%rip)      # 0x91e0
jne 0x2cb2
imulq $0x18, -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2030
movq %rax, -0x10(%rbp)
movq %rax, 0x656d(%rip)      # 0x91e0
movq -0x10(%rbp), %rax
movq 0x6562(%rip), %rcx      # 0x91e0
addq $0x170, %rcx            # imm = 0x170
cmpq %rcx, %rax
je 0x2ca7
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c73
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x6527(%rip), %rax      # 0x91e0
movq %rax, -0x10(%rbp)
movq 0x651c(%rip), %rax      # 0x91e0
movq (%rax), %rax
movq %rax, 0x6512(%rip)      # 0x91e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo04::test_per_class_allocator_1()
void test_per_class_allocator_1()
{
	cout << "\ntest_per_class_allocator_1()................ \n";
	cout << sizeof(Screen) << endl;
	//pi 下N太大会造成crash
	size_t const N = 20;
	Screen *p[N];
	for (int i=0; i<N; ++i) {
		p[i] = new Screen(i);
	}
	
	//输出前10个pointers，用以比较其间隔
	for (int i=0; i<10; ++i) {
		cout << p[i] << endl;
	}
	//result: 间隔为8，中间没有cookie
		//0x114010
		//0x114018
		//0x114020
		//0x114028
		//0x114030
		//0x114038
		//0x114040
		//0x114048
		//0x114050
		//0x114058

	for (int i=0; i<N; ++i) {
		delete p[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x6286(%rip), %rdi      # 0x8fd8
leaq 0x3356(%rip), %rsi      # 0x60af
callq 0x2190
movq 0x6273(%rip), %rdi      # 0x8fd8
movl $0x10, %esi
callq 0x2050
movq %rax, %rdi
movq 0x623f(%rip), %rsi      # 0x8fb8
callq 0x21c0
movq $0x14, -0x8(%rbp)
movl $0x0, -0xb4(%rbp)
movslq -0xb4(%rbp), %rax
cmpq $0x14, %rax
jae 0x2e0b
movl $0x10, %edi
callq 0x2c40
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movl -0xb4(%rbp), %esi
callq 0x4510
jmp 0x2dc1
movq -0xd8(%rbp), %rcx
movslq -0xb4(%rbp), %rax
movq %rcx, -0xb0(%rbp,%rax,8)
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x2d90
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
callq 0x2d10
jmp 0x2eb4
movl $0x0, -0xc8(%rbp)
cmpl $0xa, -0xc8(%rbp)
jge 0x2e59
movslq -0xc8(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rsi
movq 0x61a4(%rip), %rdi      # 0x8fd8
callq 0x2130
movq %rax, %rdi
movq 0x6175(%rip), %rsi      # 0x8fb8
callq 0x21c0
movl -0xc8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc8(%rbp)
jmp 0x2e15
movl $0x0, -0xcc(%rbp)
movslq -0xcc(%rbp), %rax
cmpq $0x14, %rax
jae 0x2eab
movslq -0xcc(%rbp), %rax
movq -0xb0(%rbp,%rax,8), %rax
movq %rax, -0xe0(%rbp)
cmpq $0x0, %rax
je 0x2e98
movq -0xe0(%rbp), %rdi
callq 0x2d10
jmp 0x2e9a
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x2e63
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x2300
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo05::AirPlane::operator new(unsigned long)
void *AirPlane::operator new(size_t size)
{
	//如果大小错误，转交给::operator new()
	if (size != sizeof(AirPlane)) {
		return ::operator new(size);
	}

	AirPlane *p = headOfFreeList;
	//如果p有效，就把list头部往下移一个元素
	if (NULL != p) {
		headOfFreeList = p->next;
	} else {
		//free list 已空，配置一块内存
		//令足够容纳BLOCK_SIZE个AirPlane
		AirPlane *newBlock = static_cast<AirPlane *>(::operator new(BLOCK_SIZE*sizeof(AirPlane)));
		for (size_t i=0; i<BLOCK_SIZE; ++i) {
			newBlock[i].next = &newBlock[i+1];
		}
		//设置最后一个为NULL
		newBlock[BLOCK_SIZE-1].next = NULL;
		//让p指向第一个元素
		p = newBlock;
		//headOfFreeList指向下一个元素
		headOfFreeList = p->next;
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x10, -0x10(%rbp)
je 0x2ee5
movq -0x10(%rbp), %rdi
callq 0x21a0
movq %rax, -0x8(%rbp)
jmp 0x2f88
movq 0x62fc(%rip), %rax      # 0x91e8
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2f08
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x62e2(%rip)      # 0x91e8
jmp 0x2f80
movl $0x2000, %edi           # imm = 0x2000
callq 0x21a0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x200, -0x28(%rbp)     # imm = 0x200
jae 0x2f5b
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
addq $0x1, %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2f1e
movq -0x20(%rbp), %rax
movq $0x0, 0x1ff0(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x6268(%rip)      # 0x91e8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: demo05::AirPlane::operator delete(void*, unsigned long)
void AirPlane::operator delete(void *deadObject, size_t size)
{
	if (NULL == deadObject) { return; }

	if (size != sizeof(AirPlane)) {
		::operator delete(deadObject);
		return;
	}

	//插入headOfFreeList之前，回收内存
	AirPlane *plane = static_cast<AirPlane *>(deadObject);
	plane->next = headOfFreeList;
	headOfFreeList = plane;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x2fba
jmp 0x2fed
cmpq $0x10, -0x10(%rbp)
je 0x2fcc
movq -0x8(%rbp), %rdi
callq 0x2180
jmp 0x2fed
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x620d(%rip), %rcx      # 0x91e8
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x61fb(%rip)      # 0x91e8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: global_new_delete::test_global_new_delete()
void test_global_new_delete()
{
	Foo *foo = new Foo();
	delete foo;
	foo = NULL;

	Foo *arrayfoo = new Foo[10];
	delete []arrayfoo;
	arrayfoo = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x1, %edi
callq 0x21a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4b60
jmp 0x3d66
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3d93
movq -0x30(%rbp), %rdi
callq 0x4bb0
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x21b0
movq $0x0, -0x8(%rbp)
movl $0x12, %edi
callq 0x2030
movq %rax, -0x50(%rbp)
movq $0xa, (%rax)
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq %rax, %rcx
addq $0xa, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4b60
jmp 0x3dd6
movq -0x40(%rbp), %rcx
movq -0x58(%rbp), %rax
addq $0x1, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x3dc7
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x3e5e
movq -0x60(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x70(%rbp)
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x68(%rbp)
je 0x3e49
movq -0x68(%rbp), %rdi
addq $-0x1, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4bb0
movq -0x60(%rbp), %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x3e27
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
shlq $0x0, %rsi
addq $0x8, %rsi
callq 0x2350
movq $0x0, -0x20(%rbp)
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x1, %esi
callq 0x21b0
jmp 0x3ee5
movq -0x48(%rbp), %rcx
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq %rax, %rcx
movq %rax, -0x88(%rbp)
je 0x3ed7
movq -0x88(%rbp), %rdi
addq $-0x1, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4bb0
movq -0x48(%rbp), %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x88(%rbp)
jne 0x3ea9
movq -0x50(%rbp), %rdi
movl $0x12, %esi
callq 0x2350
movq -0x10(%rbp), %rdi
callq 0x2300
nop
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: ext_pool_allocator::test_pool_alloc()
void test_pool_alloc()
	{
		std::cout << sizeof(__gnu_cxx::__pool_alloc<int>) << std::endl;
		cookie_test(__gnu_cxx::__pool_alloc<double>(), 1);

		std::cout << sizeof(std::allocator<int>) << std::endl;
		cookie_test(std::allocator<double>(), 1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x4ea9(%rip), %rdi      # 0x8fd8
movl $0x1, %esi
movq %rsi, -0x20(%rbp)
callq 0x2050
movq %rax, %rdi
movq 0x4e71(%rip), %rsi      # 0x8fb8
callq 0x21c0
leaq -0x1(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x4f80
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4e60
jmp 0x4168
leaq -0x1(%rbp), %rdi
callq 0x4f90
movq 0x4e60(%rip), %rdi      # 0x8fd8
movl $0x1, %esi
movq %rsi, -0x30(%rbp)
callq 0x2050
movq %rax, %rdi
movq 0x4e28(%rip), %rsi      # 0x8fb8
callq 0x21c0
leaq -0x15(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x50c0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4fa0
jmp 0x41b1
leaq -0x15(%rbp), %rdi
callq 0x50e0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x1(%rbp), %rdi
callq 0x4f90
jmp 0x41ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x50e0
movq -0x10(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: void ext_pool_allocator::cookie_test<__gnu_cxx::__pool_alloc<double>>(__gnu_cxx::__pool_alloc<double>, unsigned long)
void cookie_test(Alloc alloc, size_t n)
	{
		typename Alloc::value_type *p1, *p2, *p3;

		p1 = alloc.allocate(n);
		p2 = alloc.allocate(n);
		p3 = alloc.allocate(n);

		std::cout << "p1=" << p1 << "\t" << "p2=" << p2 << "\t" << "p3=" << p3 << "\t" << std::endl;

		alloc.deallocate(p1, sizeof(typename Alloc::value_type));
		alloc.deallocate(p2, sizeof(typename Alloc::value_type));
		alloc.deallocate(p3, sizeof(typename Alloc::value_type));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5470
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5470
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5470
movq %rax, -0x28(%rbp)
movq 0x4122(%rip), %rdi      # 0x8fd8
leaq 0x15fc(%rip), %rsi      # 0x64b9
callq 0x2190
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x15e5(%rip), %rsi      # 0x64bd
callq 0x2190
movq %rax, %rdi
leaq 0x15d8(%rip), %rsi      # 0x64bf
callq 0x2190
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x15bb(%rip), %rsi      # 0x64bd
callq 0x2190
movq %rax, %rdi
leaq 0x15b2(%rip), %rsi      # 0x64c3
callq 0x2190
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x1591(%rip), %rsi      # 0x64bd
callq 0x2190
movq %rax, %rdi
movq 0x407d(%rip), %rsi      # 0x8fb8
callq 0x21c0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x5710
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x5710
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x5710
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: custom_allocator::allocator::alloc(unsigned long)
void *alloc(const size_t size)
	{
		object *p = NULL;
		if (NULL == freeHead) {
			p = freeHead = (object *)malloc(chunksize*size);
			for (int i=0; i<chunksize-1; ++i) {
				p->next = (object *)((char *)p+size);
				p = p->next;
			}
			p->next = NULL; //last
		}
		p = freeHead;
		freeHead = freeHead->next;
		return p;
	}

// 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)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0x518c
movq -0x28(%rbp), %rax
movslq (%rax), %rdi
imulq -0x10(%rbp), %rdi
callq 0x2260
movq -0x28(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5181
movq -0x18(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x514c
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Azer0s[P]littl/bin/../src/tree/base/native.hpp
// Function: littl::Native::Native(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Native(const std::string& name){
                std::regex str("^.(.*)..$");
                const char* c = name.c_str();
                std::cmatch cm;
                std::regex_match(c,cm,str,std::regex_constants::match_default);
                this->name = cm[1];
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xbd20
movq -0x98(%rbp), %rdi
leaq 0x593e7(%rip), %rax     # 0x64518
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x90(%rbp)
callq 0x7590
leaq 0x3af62(%rip), %rsi     # 0x460ad
leaq -0x30(%rbp), %rdi
movl $0x10, %edx
callq 0xd550
jmp 0xb15b
movq -0x10(%rbp), %rdi
callq 0x71a0
movq %rax, -0x48(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xd5f0
jmp 0xb173
movq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0xd630
jmp 0xb188
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0xd690
movq %rax, -0xa0(%rbp)
jmp 0xb19f
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xd700
jmp 0xb1b4
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
leaq -0x88(%rbp), %rsi
callq 0x7500
leaq -0x88(%rbp), %rdi
callq 0x72a0
leaq -0x68(%rbp), %rdi
callq 0xd730
leaq -0x30(%rbp), %rdi
callq 0xd750
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xb22c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xb223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xd730
leaq -0x30(%rbp), %rdi
callq 0xd750
movq -0x90(%rbp), %rdi
callq 0x72a0
movq -0x98(%rbp), %rdi
callq 0xc180
movq -0x38(%rbp), %rdi
callq 0x7740
nopl (%rax)
// File: Azer0s[P]littl/bin/../src/tree/blocks/ifElseIfElse.hpp
// Function: littl::IfElseIfElse::IfElseIfElse(littl::SyntaxTree*, littl::SyntaxTree*, littl::SyntaxTree*, littl::SyntaxTree*)
IfElseIfElse(SyntaxTree* condition, SyntaxTree* block, SyntaxTree* elseIfBlock, SyntaxTree* elseBlock){
                this->condition = condition;
                this->block = block;
                this->elseIfBlock = elseIfBlock;
                this->elseBlock = elseBlock;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xbd20
movq -0x30(%rbp), %rax
leaq 0x594ec(%rip), %rcx     # 0x649c0
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Azer0s[P]littl/bin/../src/tree/blocks/countedFor.hpp
// Function: littl::CountedFor::CountedFor(littl::SyntaxTree*, littl::SyntaxTree*, littl::SyntaxTree*, littl::SyntaxTree*)
CountedFor(SyntaxTree* var, SyntaxTree* condition, SyntaxTree* op, SyntaxTree* block){
                this->var = var;
                this->condition = condition;
                this->op = op;
                this->block = block;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xbd20
movq -0x30(%rbp), %rax
leaq 0x594ac(%rip), %rcx     # 0x64a40
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Azer0s[P]littl/bin/../src/tree/values/littlBool.hpp
// Function: littl::LittlBool::LittlBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
LittlBool(const std::string& val){
                if(val == "true"){
                    value = true;
                }else{
                    value = false;
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xbd20
movq -0x18(%rbp), %rax
leaq 0x59118(%rip), %rcx     # 0x64c40
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x3aec2(%rip), %rsi     # 0x469fc
callq 0x1b1d0
testb $0x1, %al
jne 0xbb45
jmp 0xbb4f
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0xbb57
movq -0x18(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Azer0s[P]littl/bin/../src/tree/program.hpp
// Function: littl::Program::toCode[abi:cxx11]() const
virtual std::string toCode() const{
                std::string program;
                for(SyntaxTree* node : tree){
                    program += node->toCode();
                }
                return program;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7590
movq -0x70(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc2b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc2e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xccf0
testb $0x1, %al
jne 0xc0d8
jmp 0xc143
leaq -0x28(%rbp), %rdi
callq 0xcd30
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xc0fb
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7530
jmp 0xc10a
leaq -0x58(%rbp), %rdi
callq 0x72a0
leaq -0x28(%rbp), %rdi
callq 0xcd50
jmp 0xc0c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc163
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x72a0
jmp 0xc163
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc156
movq -0x80(%rbp), %rdi
callq 0x72a0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x72a0
movq -0x60(%rbp), %rdi
callq 0x7740
nopw %cs:(%rax,%rax)
nop