LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/clustering.cpp
// Function: trivial_decompression(std::vector<int, std::allocator<int>>*, int, int, int, double&)
void trivial_decompression(vector<int>* data, int nproc, int rank, int round, double& dcomtime)
{
	double start = MPI_Wtime();

	vector <int> parser;
	parser.reserve((*data).size());
	parser = (*data);
	(*data).clear();

	int pid_count = parser[0], pos, i, j, pid, npid, npid_count;
	
	pos++;

	while(pid_count > 0)
	{
		pid = parser[pos++];
		npid_count = parser[pos++];

		for(j = 0; j < npid_count; j++)
		{
			(*data).push_back(pid);
			(*data).push_back(parser[pos++]);
		}

		pid_count--;
	}

	parser.clear();

	double stop = MPI_Wtime();

	dcomtime += (stop - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rdi, %r14
callq 0x3360
movsd %xmm0, -0x60(%rbp)
xorpd %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movapd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
callq 0x1000e
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0xcad0
movq %rbx, -0x58(%rbp)
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0xccb6
movq %rax, 0x8(%r14)
movq -0x50(%rbp), %rax
movl (%rax), %r12d
testl %r12d, %r12d
jle 0xcd5d
movslq %edx, %rax
movq -0x50(%rbp), %rcx
movl (%rcx,%rax,4), %edx
movl %edx, -0x2c(%rbp)
leal 0x2(%rax), %edx
movl 0x4(%rcx,%rax,4), %ebx
testl %ebx, %ebx
jle 0xcd4b
movl %edx, -0x30(%rbp)
movslq %edx, %r15
shlq $0x2, %r15
negl %ebx
xorl %r13d, %r13d
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xcd06
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xcd12
movq %r14, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x50ac
movq -0x50(%rbp), %rdx
addq %r15, %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xcd31
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xcd39
movq %r14, %rdi
callq 0x50ac
addq $0x4, %r15
decl %r13d
cmpl %r13d, %ebx
jne 0xcced
movl -0x30(%rbp), %edx
subl %r13d, %edx
leal -0x1(%r12), %eax
cmpl $0x1, %r12d
movl %eax, %r12d
jg 0xccc6
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
je 0xcd6b
movq %rax, -0x48(%rbp)
callq 0x3360
movq -0x58(%rbp), %rax
subsd -0x60(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xcd8f
callq 0x3270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcda2
jmp 0xcda2
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xcdb3
callq 0x3270
movq %rbx, %rdi
callq 0x34c0
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/main.cpp
// Function: populateSingle(dataHdr**, char*, int*, int*)
int populateSingle(DataHdr* dataList, char* argv, int* totalSize, int* dims)
{

	vector< vector<double> > objects;

	int localSize = fileReadSingle(argv, totalSize, dims, objects);

	*dataList = initDataHdr(objects.size());

	populateDataListLocal(*dataList, objects);

	return localSize;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x908c
movl %eax, %ebx
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %edi # imm = 0xAAAAAAAB
callq 0x3d63
movq %rax, (%r14)
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3fe6
leaq -0x30(%rbp), %rdi
callq 0x41f2
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x41f2
movq %rbx, %rdi
callq 0x34c0
// File: /workspace/github_cpp_makefile_star2_O1/ADAPTLab[P]MuDBSCAN/main.cpp
// Function: createDebugCSV(dataHdr*, int)
void createDebugCSV(DataHdr dataList, int rank)
{
	FILE* debug1;
	string currFile1("");

	currFile1 = debugFileName + patch::to_string(rank);

	debug1 = fopen(currFile1.c_str(), "w");

	printf("Before Remote Points Procedure %d \n",rank);
	for(int i = 0; i < dataList->localCnt; i++)
	{
		Data datai = dataList->dataClstElem + i;
		if(debug1!=NULL){
			fprintf(debug1, "%lf\t%lf\t%lf\t%d\n",datai->iData[0],datai->iData[1],datai->iData[2],(int)datai->core_tag); 

		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq -0x2c(%rbp), %r14
movl %esi, (%r14)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1c46(%rip), %rdx      # 0x12029
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0xbb30
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0xb463
leaq 0x6ede(%rip), %r14      # 0x172e0
movq %r14, %rdi
callq 0x3120
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x32c0
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x10444
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x1044b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x90(%rbp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x3340
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x10482
callq 0x3270
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10494
callq 0x3270
movq -0x50(%rbp), %rdi
leaq 0x1dd5(%rip), %rsi      # 0x12274
callq 0x3300
movq %rax, %r14
movl -0x2c(%rbp), %esi
leaq 0x1dff(%rip), %rdi      # 0x122b0
xorl %eax, %eax
callq 0x3050
cmpl $0x0, 0x4(%rbx)
jle 0x10508
xorl %r13d, %r13d
leaq 0x1e0c(%rip), %r15      # 0x122d4
xorl %r12d, %r12d
testq %r14, %r14
je 0x104f8
movq 0x8(%rbx), %rax
movq (%rax,%r13), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
movsd 0x10(%rcx), %xmm2
movl 0x28(%rax,%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
movb $0x3, %al
callq 0x3400
incq %r12
movslq 0x4(%rbx), %rax
addq $0x40, %r13
cmpq %rax, %r12
jl 0x104cb
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1051a
callq 0x3270
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10543
callq 0x3270
jmp 0x10543
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x10555
callq 0x3270
movq %rbx, %rdi
callq 0x34c0
// File: /workspace/github_cpp_makefile_star2_O1/Gilaverbuch[P]FD_2D_WAVE/wave.cpp
// Function: main
int main()
{	

	model_parameters model;
	model.print_parameters();
	Field displacement(model);
	displacement.Propagator();

	// std::cout << "number of elements" << " " << elements_ << std::endl;
	// int n=10;
	// int a[n] = {};

	// std::cout << a[0] << " " << a[5] << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
callq 0x25b0
movq %rbx, %rdi
callq 0x2c82
leaq -0x130(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x35d8
leaq -0x130(%rbp), %rdi
callq 0x3a4e
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x2503
movq -0x10(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2518
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x252d
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2180
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %rbp
retq
jmp 0x253b
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2552
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Gilaverbuch[P]FD_2D_WAVE/model_parameters.cpp
// Function: model_parameters::extractNumbersWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double model_parameters::extractNumbersWords(std::string str){ 
    std::stringstream ss;     
  
    /* Storing the whole string into string stream */
    ss << str; 
  
    /* Running loop till the end of the stream */
    std::string temp; 
    double found, val; 
    while (!ss.eof()) { 
  
        // extracting word by word from stream 
        ss >> temp; 
  
        /* Checking the given word is integer or not */
        if (std::stringstream(temp) >> found) 
            // std::cout << found << std::endl;
  			val=found;
        /* To save from space at the end of string */
        temp = ""; 
    } 
   	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rsi, %rbx
leaq -0x1e0(%rbp), %rdi
callq 0x20e0
leaq -0x1d0(%rbp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x21b0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %r15
leaq -0x368(%rbp), %r12
movq 0x4699(%rip), %rbx      # 0x6fb8
leaq 0x28e9(%rip), %r14      # 0x520f
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1c0(%rbp,%rax)
jne 0x29b9
leaq -0x1e0(%rbp), %rdi
movq %r15, %rsi
callq 0x21d0
movq %r12, %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x2220
movq %r12, %rdi
leaq -0x58(%rbp), %rsi
callq 0x20c0
movq -0x368(%rbp), %rax
movq -0x18(%rax), %rax
movb -0x348(%rbp,%rax), %r13b
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2100
leaq -0x2e8(%rbp), %rdi
callq 0x2060
testb $0x5, %r13b
jne 0x29a0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x2210
jmp 0x2926
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x29d2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq 0x45df(%rip), %rsi      # 0x6fb8
leaq -0x1e0(%rbp), %rdi
callq 0x2100
leaq -0x160(%rbp), %rdi
callq 0x2060
movsd -0x50(%rbp), %xmm0
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2a4f
jmp 0x2a33
movq %rax, %rbx
movq 0x459f(%rip), %rsi      # 0x6fb8
leaq -0x368(%rbp), %rdi
callq 0x2100
leaq -0x2e8(%rbp), %rdi
callq 0x2060
jmp 0x2a36
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2a4f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2180
movq 0x4562(%rip), %rsi      # 0x6fb8
leaq -0x1e0(%rbp), %rdi
callq 0x2100
leaq -0x160(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Gilaverbuch[P]FD_2D_WAVE/model_parameters.cpp
// Function: model_parameters::read_vel_profile()
void model_parameters::read_vel_profile(){

	std::ifstream inFile;

	inFile.open("vel_profile.txt");

	while(!inFile.eof())
	{
	    int  a;
	    double b, c;
	    inFile >> a >> b >> c; // extracts 3 values for layer


	    x_range.push_back(a);
		density_range.push_back(b);
		velocity_range.push_back(c);
	}
	layers = x_range.size();

	std::cout << layers << " " << velocity_range[0] << " " << velocity_range[1] << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq -0x260(%rbp), %r14
movq %r14, %rdi
callq 0x21a0
leaq 0x2668(%rip), %rsi      # 0x510b
movq %r14, %rdi
movl $0x8, %edx
callq 0x20b0
movq -0x260(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x240(%rbp,%rax)
jne 0x2bb1
leaq 0x50(%rbx), %rax
movq %rax, -0x48(%rbp)
leaq 0x68(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x80(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq -0x260(%rbp), %r13
leaq -0x2c(%rbp), %r14
leaq -0x58(%rbp), %r15
leaq -0x50(%rbp), %r12
movq %r13, %rdi
movq %r14, %rsi
callq 0x20a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x20c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x20c0
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x2b31
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x58(%rbx)
jmp 0x2b3d
movq -0x48(%rbp), %rdi
movq %r14, %rdx
callq 0x3352
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x2b5a
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x2b66
movq -0x40(%rbp), %rdi
movq %r15, %rdx
callq 0x3492
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x2b8c
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x88(%rbx)
jmp 0x2b98
movq -0x38(%rbp), %rdi
movq %r12, %rdx
callq 0x3492
movq -0x260(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x240(%rbp,%rax)
je 0x2af7
movq 0x58(%rbx), %rsi
subq 0x50(%rbx), %rsi
shrq $0x2, %rsi
movl %esi, 0x18(%rbx)
movq 0x4411(%rip), %rdi      # 0x6fd8
callq 0x2260
movq %rax, %r14
leaq 0x2638(%rip), %rsi      # 0x520e
movl $0x1, %edx
movq %rax, %rdi
callq 0x21b0
movq 0x80(%rbx), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x2230
movq %rax, %r14
leaq 0x260e(%rip), %rsi      # 0x520e
movl $0x1, %edx
movq %rax, %rdi
callq 0x21b0
movq 0x80(%rbx), %rax
movsd 0x8(%rax), %xmm0
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
leaq -0x260(%rbp), %rdi
callq 0x2050
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c6b
movq %rax, %rbx
leaq -0x260(%rbp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Gilaverbuch[P]FD_2D_WAVE/Field.cpp
// Function: Field::initialize(int, int, double**, std::vector<int, std::allocator<int>>, std::vector<double, std::allocator<double>>)
void Field::initialize(int size_y, int size_x, double **A, std::vector<int>  x_range, std::vector<double> val){

	int i, k, j, pos1, pos2;
	pos1 = 0;

	for (k=0; k<int(x_range.size()); k++){

		pos2 = int(x_range[k]/dx);

		for (i=pos1; i<pos2; i++){

			for (j=0; j<size_x; j++){

				A[i][j] = val[k];

			}
		}
		pos1 = pos2; 
	}
	
}

// Assembly:
movq (%r8), %r10
movq 0x8(%r8), %r8
subq %r10, %r8
shrq $0x2, %r8
testl %r8d, %r8d
jle 0x3a4d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %esi
movl 0x70(%rdi), %edi
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl %edx, %r11d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl (%r10,%rbx,4), %eax
cltd
idivl %edi
cmpl %eax, %r14d
jge 0x3a38
movslq %r14d, %rdx
movslq %eax, %r14
testl %esi, %esi
jle 0x3a30
movq (%r9), %r15
movq (%rcx,%rdx,8), %r12
xorl %r13d, %r13d
movsd (%r15,%rbx,8), %xmm0
movsd %xmm0, (%r12,%r13,8)
incq %r13
cmpq %r13, %r11
jne 0x3a1c
incq %rdx
cmpq %r14, %rdx
jne 0x3a0e
incq %rbx
movl %eax, %r14d
cmpq %r8, %rbx
jne 0x39fc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/candies.cpp
// Function: getMinimumCandies(std::vector<int, std::allocator<int>>)
int getMinimumCandies(vector<int> c) {
    int N = c.size();
    vector<int> minR = vector<int>(N, 1);
    vector<int> minL = vector<int>(N, 1);

    for (int i = N - 2; i >= 0; i--) {
        if (c[i + 1] < c[i])
            minR[i] = 1 + minR[i + 1];
    }

    for (int i = 1; i < N; i++) {
        if (c[i - 1] < c[i])
            minL[i] = 1 + minL[i - 1];
    }

    int t = 0;
    for (int i = 0; i < N; i++)
        t += max(minR[i], minL[i]);

    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x2, %r12
movslq %r12d, %r14
movl $0x1, %ebp
leaq 0x28(%rsp), %rdx
movl %ebp, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %r15
movq %r14, %rsi
movq %r15, %rcx
callq 0x14e8
movl %ebp, (%r15)
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rdx
leaq 0xb(%rsp), %rcx
movq %r14, %rsi
callq 0x14e8
cmpl $0x2, %r12d
jl 0x12d1
leal -0x2(%r12), %eax
movq (%rbx), %rcx
movq 0x10(%rsp), %rdx
incq %rax
movl (%rcx,%rax,4), %esi
cmpl -0x4(%rcx,%rax,4), %esi
jge 0x12cc
movl (%rdx,%rax,4), %esi
incl %esi
movl %esi, -0x4(%rdx,%rax,4)
decq %rax
jg 0x12ba
cmpl $0x2, %r12d
jl 0x1307
movq (%rbx), %rax
movq 0x28(%rsp), %rcx
movl %r12d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x1, %esi
movl -0x4(%rax,%rsi,4), %edi
cmpl (%rax,%rsi,4), %edi
jge 0x12ff
movl -0x4(%rcx,%rsi,4), %edi
incl %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x12ed
testl %r12d, %r12d
jle 0x1338
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %ebx, %ebx
movl (%rax,%rdx,4), %esi
movl (%rcx,%rdx,4), %edi
cmpl %edi, %esi
cmovgl %esi, %edi
addl %edi, %ebx
incq %rdx
cmpq %rdx, %r12
jne 0x1321
jmp 0x133a
xorl %ebx, %ebx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1351
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1368
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1391
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/candies.cpp
// Function: main
int main() {
    int N, x;
    cin >> N;

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

    cout << getMinimumCandies(c) << endl;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2c36(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x141b
xorl %ebp, %ebp
movq 0x2c0a(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1408
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1413
movq %r15, %rdi
movq %r14, %rdx
callq 0x16f8
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x13e0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x165c
leaq 0x30(%rsp), %rdi
callq 0x124c
movq 0x2b95(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1483
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x149a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14c5
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14c8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
jmp 0x14c8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14df
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/tree/./tree.h
// Function: problem_t::fill_noisy_states()
void fill_noisy_states() {
        if( r_ > 0.0 ) {
            Problem::hash_t<state_t> hash(*this);
            Algorithm::state_space_t<state_t> state_space(*this);
            state_space.generate_space(init_, hash);
            for( Problem::hash_t<state_t>::const_iterator hi = hash.begin(); hi != hash.end(); ++hi ) {
                if( Random::real() < r_ ) noisy_.insert((*hi).first);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorps %xmm0, %xmm0
ucomiss 0x24(%rdi), %xmm0
jae 0x8a4d
movq %rdi, %rbx
leaq 0x48(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq $0x0, 0x8(%rax)
leaq 0x2b3cf(%rip), %rcx     # 0x33db0
movq %rcx, -0x38(%rax)
movq %rdi, 0x10(%rax)
movl $0x0, 0x18(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdx
callq 0x8d66
movq 0x28(%rsp), %r12
testq %r12, %r12
je 0x8a43
leaq 0x30(%rbx), %r14
movq %rsp, %r15
callq 0x51e0
cvtsd2ss %xmm0, %xmm0
ucomiss 0x24(%rbx), %xmm0
jae 0x8a3a
leaq 0x8(%r12), %rsi
movq %r14, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x95b8
movq (%r12), %r12
testq %r12, %r12
jne 0x8a17
leaq 0x10(%rsp), %rdi
callq 0x130c8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8a5b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x130c8
movq %rbx, %rdi
callq 0x5370
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/tree/./tree.h
// Function: state_t::print(std::ostream&) const
void print(std::ostream &os) const {
        bits_t b1(branch1()), b2(data2_);
        os << "( " << depth()
           << " , [" << branch1()
           << "|" << data2_
           << "]:" << b1
           << "|" << b2 << " )";
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3ffffff, %r15d       # imm = 0x3FFFFFF
andl (%rdi), %r15d
movl 0x4(%rdi), %ebp
leaq 0x135b4(%rip), %rsi     # 0x26bb4
movl $0x2, %edx
movq %r14, %rdi
callq 0x5250
movl (%rbx), %esi
shrl $0x1a, %esi
movq %r14, %rdi
callq 0x5160
movq %rax, %r14
leaq 0x13593(%rip), %rsi     # 0x26bb7
movl $0x4, %edx
movq %rax, %rdi
callq 0x5250
movl (%rbx), %esi
andl $0x3ffffff, %esi        # imm = 0x3FFFFFF
movq %r14, %rdi
callq 0x5160
movq %rax, %r14
leaq 0x13571(%rip), %rsi     # 0x26bbc
movl $0x1, %edx
movq %rax, %rdi
callq 0x5250
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x5160
movq %rax, %rbx
leaq 0x13551(%rip), %rsi     # 0x26bbe
movl $0x2, %edx
movq %rax, %rdi
callq 0x5250
movl $0x1f, %r14d
xorl %esi, %esi
btl %r14d, %r15d
setb %sil
movq %rbx, %rdi
callq 0x5160
addl $-0x1, %r14d
jb 0x13680
leaq 0x1351d(%rip), %rsi     # 0x26bbc
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5250
movl $0x1f, %r14d
xorl %esi, %esi
btl %r14d, %ebp
setb %sil
movq %rbx, %rdi
callq 0x5160
addl $-0x1, %r14d
jb 0x136b2
leaq 0x134f0(%rip), %rsi     # 0x26bc1
movl $0x2, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5250
// File: /workspace/github_cpp_makefile_star2_O1/smuething[P]dune-cxx11/09-initializer_list.cc
// Function: foo(std::initializer_list<int>)
int foo(std::initializer_list<int> il)
{
  int res = 0;
  for (const int* it = il.begin(); it != il.end(); ++it)
    res += *it;
  return res;
}

// Assembly:
testq %rsi, %rsi
je 0x1156
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
addl (%rdi,%rcx), %eax
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x1149
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::parseFeatureName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
params_hash
CerebronPredictor::parseFeatureName(string feature_name)
{
	params_hash result;

	vector<string> split_line = split(feature_name , '_');
	result.index = split_line[0];
	result.nbBlock = atoi(split_line[1].c_str());
	
	if(split_line.size() == 3)
		result.xorWithPC = split_line[2] == "1" ? true : false;
	else
		result.xorWithPC = false;
		
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0xc986
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xcc1c
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x5f, %edx
callq 0x2e5ac
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x76c8
callq 0x52a0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x51a0
movq 0x8(%rsp), %r14
movq 0x20(%r14), %rdi
callq 0x54c0
movl %eax, 0x24(%rbx)
movq 0x10(%rsp), %rax
subq %r14, %rax
cmpq $0x60, %rax
jne 0x770f
addq $0x40, %r14
leaq 0x2dfab(%rip), %rsi     # 0x356aa
movq %r14, %rdi
callq 0x50f0
testl %eax, %eax
sete 0x20(%rbx)
jmp 0x7713
movb $0x0, 0x20(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xc830
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc830
jmp 0x7750
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x7750
callq 0x52a0
jmp 0x7750
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x7761
callq 0x52a0
movq %r14, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::allocateInNVM(unsigned long, Access)
allocDecision
CerebronPredictor::allocateInNVM(uint64_t set, Access element)
{
//	if(element.isInstFetch())
//		return ALLOCATE_IN_NVM;
	
	update_globalPChistory(element.m_pc);
	if( hitInSRAMMissingTags( element.block_addr, set) )
		element.m_pc = missingTagMissPC( element.block_addr , set);
		
	return activationFunction(element.isWrite() , element.block_addr , element.m_pc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq 0x10(%r12), %rsi
callq 0x27862
movq 0x30(%r12), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x273ca
testb %al, %al
je 0x77b1
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2702a
movq %rax, 0x10(%r12)
movl 0x1c(%r12), %eax
cmpl $0x3, %eax
sete %cl
cmpl $0x6, %eax
sete %al
orb %cl, %al
movq 0x10(%r12), %rcx
movzbl %al, %esi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x77e2
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::classifyRD(int, int, bool)
RD_TYPE
CerebronPredictor::classifyRD(int set , int index, bool inNVM)
{
	vector<CacheEntry*> line;
	int64_t ref_rd = 0;
	if(inNVM)
	{
		ref_rd = m_tableNVM[set][index]->policyInfo;
		line = m_tableNVM[set];
	}
	else
	{
		line = m_tableSRAM[set];
		ref_rd = m_tableSRAM[set][index]->policyInfo;
	}
	
	int position = 0;
	/* Determine the position of the cache line in the LRU stack */
//	debug_file << "classifyRD, cpt_time =  " << cpt_time << ", set = " << set << " col = " << index << ", ref_rd = " << ref_rd << endl;
	for(unsigned i = 0 ; i < line.size() ; i ++)
	{
//		debug_file << "\tPolicy[" << i << "] = " << line[i]->policyInfo << endl;
		if(line[i]->policyInfo > ref_rd && line[i]->isValid)
			position++;
	}	
//	debug_file << "Position = " << position << endl;

	if(simu_parameters.nvm_assoc > simu_parameters.sram_assoc)
	{
		if(position < simu_parameters.mediumrd_def)
			return RD_SHORT;
		else
			return RD_MEDIUM;	
	}
	else
	{
		if(position < simu_parameters.mediumrd_def)
			return RD_SHORT;
		else
			return RD_MEDIUM;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movslq %esi, %rax
testl %ecx, %ecx
je 0x9542
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rsi
movslq %ebx, %rax
movq (%rsi), %rcx
movq (%rcx,%rax,8), %rax
movl 0x38(%rax), %ebx
movq %rsp, %rdi
callq 0xc8b8
jmp 0x9572
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %r15
leaq (,%r15,8), %rsi
addq (%rcx), %rsi
movq %rsp, %rdi
callq 0xc8b8
movq 0x8(%r14), %rax
movq (%rax), %rax
movslq %ebx, %rcx
movq (%rax,%r15,8), %rax
movq (%rax,%rcx,8), %rax
movl 0x38(%rax), %ebx
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x95a2
sarq $0x3, %rax
xorl %ecx, %ecx
xorl %ebp, %ebp
movq (%rdi,%rcx,8), %rdx
cmpl %ebx, 0x38(%rdx)
jle 0x9596
movzbl (%rdx), %edx
addl %edx, %ebp
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x9588
jmp 0x95a4
xorl %ebp, %ebp
leaq 0x3c9a5(%rip), %rax     # 0x45f50
movl 0x1fc(%rax), %ebx
testq %rdi, %rdi
je 0x95bb
callq 0x52a0
xorl %eax, %eax
cmpl %ebx, %ebp
setge %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x95de
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::openNewTimeFrame()
void
CerebronPredictor::openNewTimeFrame()
{
	stats_nbBPrequests.push_back(0);
	stats_nbDeadLine.push_back(0);
	
	stats_missCounter.push_back( miss_counter );
	stats_nbHits = 0, stats_nbMiss = 0;
	
	if(simu_parameters.perceptron_compute_variance)
	{
		if(stats_variances_buffer.size() != 0)
		{
			double avg = 0;
			for(unsigned i = 0 ; i < stats_variances_buffer.size() ; i++)
				avg += stats_variances_buffer[i];
			avg /= (double)stats_variances_buffer.size();

			stats_variances.push_back(avg);	
			stats_variances_buffer.clear();
		}
	}

	for(auto feature : m_features)
		feature->openNewTimeFrame();
	
	
	Predictor::openNewTimeFrame();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq 0x390(%rdi), %rsi
cmpq 0x398(%rdi), %rsi
je 0xbead
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x390(%rbx)
jmp 0xbebe
leaq 0x388(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd572
movq $0x0, 0x8(%rsp)
movq 0x3a8(%rbx), %rsi
cmpq 0x3b0(%rbx), %rsi
je 0xbeeb
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x3a8(%rbx)
jmp 0xbefc
leaq 0x3a0(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd572
movq 0x3c0(%rbx), %rsi
cmpq 0x3c8(%rbx), %rsi
je 0xbf24
leaq 0x3a28d(%rip), %rax     # 0x461a0
movl (%rax), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x3c0(%rbx)
jmp 0xbf37
leaq 0x3b8(%rbx), %rdi
leaq 0x3a26e(%rip), %rdx     # 0x461a0
callq 0xd68c
xorpd %xmm0, %xmm0
movupd %xmm0, 0x3d0(%rbx)
leaq 0x3a006(%rip), %rax     # 0x45f50
cmpb $0x1, 0x1cd(%rax)
jne 0xc010
movq 0x3e0(%rbx), %rcx
movq 0x3e8(%rbx), %rax
subq %rcx, %rax
je 0xc010
sarq $0x3, %rax
movq $0x0, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0xbf81
movq %rax, %xmm0
punpckldq 0x2806d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x28075(%rip), %xmm0    # 0x34020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x400(%rbx), %rsi
cmpq 0x408(%rbx), %rsi
je 0xbfe8
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x400(%rbx)
jmp 0xbff9
leaq 0x3f8(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xd7a4
movq 0x3e0(%rbx), %rax
cmpq %rax, 0x3e8(%rbx)
je 0xc010
movq %rax, 0x3e8(%rbx)
movq 0x270(%rbx), %r14
movq 0x278(%rbx), %r15
cmpq %r15, %r14
je 0xc031
movq (%r14), %rdi
callq 0x14bb2
addq $0x8, %r14
jmp 0xc01e
movq %rbx, %rdi
callq 0x27496
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::finishSimu()
void 
CerebronPredictor::finishSimu()
{
	if(simu_parameters.perceptron_drawFeatureMaps)
	{
		drawFeatureMaps();
	}

	CacheEntry* entry = NULL;
	for(int i = 0 ; i < m_nb_set ; i++)
	{
		for(int j = 0 ; j < m_nbNVMways ; j++)
		{
			entry = m_tableNVM[i][j];		

			if(!entry->isValid)
				continue;
				
			allocDecision des = getDecision(entry);
			if(des != ALLOCATE_IN_NVM)				
				stats_wrong_alloc++;
			else
				stats_good_alloc++;
		}
		for(int j = 0 ; j < m_nbSRAMways ; j++)
		{
			entry = m_tableSRAM[i][j];		

			if(!entry->isValid)
				continue;

			allocDecision des = getDecision(entry);
			if(des != ALLOCATE_IN_SRAM)				
				stats_wrong_alloc++;
			else
				stats_good_alloc++;
		}
	}
	
	
	for(auto feature : m_features)
		feature->finishSimu();

	Predictor::finishSimu();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39ef7(%rip), %r14     # 0x45f50
cmpb $0x1, 0x1cc(%r14)
jne 0xc06b
movq %rbx, %rdi
callq 0xc1b6
movslq 0x18(%rbx), %rax
testq %rax, %rax
jle 0xc185
movl 0x20(%rbx), %ecx
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
movb 0x226(%r14), %dil
movl 0x24(%rbx), %r8d
movq 0x430(%rbx), %r9
movq 0x438(%rbx), %r10
xorl %r11d, %r11d
xorpd %xmm0, %xmm0
leaq (%r11,%r11,2), %r14
testl %ecx, %ecx
jle 0xc10e
movq (%rsi), %r15
movq (%r15,%r14,8), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %r13
cmpb $0x1, (%r13)
jne 0xc106
testb $0x1, %dil
je 0xc0da
movq 0x138(%r13), %rbp
cmpq 0x140(%r13), %rbp
seta %bpl
jmp 0xc0eb
movsd 0x130(%r13), %xmm1
ucomisd %xmm0, %xmm1
setbe %bpl
testb %bpl, %bpl
je 0xc0fc
incq %r9
movq %r9, 0x430(%rbx)
jmp 0xc106
incq %r10
movq %r10, 0x438(%rbx)
incq %r12
cmpq %r12, %rcx
jne 0xc0b5
testl %r8d, %r8d
jle 0xc179
movq (%rdx), %r15
movq (%r15,%r14,8), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %r12
cmpb $0x1, (%r12)
jne 0xc171
testb $0x1, %dil
je 0xc144
movq 0x138(%r12), %r13
cmpq 0x140(%r12), %r13
seta %bpl
jmp 0xc156
movsd 0x130(%r12), %xmm1
ucomisd %xmm0, %xmm1
setbe %bpl
testb %bpl, %bpl
je 0xc167
incq %r10
movq %r10, 0x438(%rbx)
jmp 0xc171
incq %r9
movq %r9, 0x430(%rbx)
incq %r15
cmpq %r15, %r8
jne 0xc11d
incq %r11
cmpq %rax, %r11
jne 0xc0a3
movq 0x270(%rbx), %r14
movq 0x278(%rbx), %rbx
cmpq %rbx, %r14
je 0xc1a6
movq (%r14), %rdi
callq 0x14d7e
addq $0x8, %r14
jmp 0xc193
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::~DBAMBPredictor()
DBAMBPredictor::~DBAMBPredictor()
{
//	myFile.close();
	
	for(auto sets : m_DHPTable)
		for(auto entry : sets)
			delete entry;
	if(simu_parameters.printDebug)
		dataset_file.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x3649f(%rip), %rax     # 0x44618
movq %rax, (%rdi)
movq 0x2e8(%rdi), %r14
movq %rdi, 0x8(%rsp)
movq 0x2f0(%rdi), %r13
cmpq %r13, %r14
je 0xe223
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1206c
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rbx
cmpq %rbx, %rbp
je 0xe207
movq (%rbp), %r12
testq %r12, %r12
je 0xe201
movq 0xa0(%r12), %rdi
testq %rdi, %rdi
je 0xe1d2
callq 0x52a0
leaq 0x58(%r12), %rdi
callq 0x121dc
movq 0x40(%r12), %rdi
testq %rdi, %rdi
je 0xe1eb
callq 0x52a0
movq (%r12), %rdi
testq %rdi, %rdi
je 0xe1f9
callq 0x52a0
movq %r12, %rdi
callq 0x52a0
addq $0x8, %rbp
jmp 0xe1b2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe216
callq 0x52a0
addq $0x18, %r14
cmpq %r13, %r14
jne 0xe19d
leaq 0x37d26(%rip), %rax     # 0x45f50
cmpb $0x0, (%rax)
je 0xe23b
leaq 0x37432(%rip), %rdi     # 0x45668
callq 0x5430
movq 0x8(%rsp), %rbx
leaq 0x3d0(%rbx), %rdi
callq 0x11fd6
leaq 0x3b8(%rbx), %rdi
callq 0xc642
leaq 0x3a0(%rbx), %rdi
callq 0xc642
movq 0x388(%rbx), %rdi
testq %rdi, %rdi
je 0xe275
callq 0x52a0
leaq 0x2e8(%rbx), %r14
movq 0x340(%rbx), %rdi
testq %rdi, %rdi
je 0xe28d
callq 0x52a0
leaq 0x308(%rbx), %rdi
callq 0x12202
movq %r14, %rdi
callq 0x1202c
movq 0x2d0(%rbx), %rdi
testq %rdi, %rdi
je 0xe2b2
callq 0x52a0
movq 0x2b8(%rbx), %rdi
testq %rdi, %rdi
je 0xe2c3
callq 0x52a0
movq 0x2a0(%rbx), %rdi
testq %rdi, %rdi
je 0xe2d4
callq 0x52a0
movq 0x280(%rbx), %rdi
leaq 0x290(%rbx), %rax
cmpq %rax, %rdi
je 0xe2ec
callq 0x52a0
movq %rbx, %rdi
callq 0x284d2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe307
jmp 0xe307
movq %rax, %rdi
callq 0xc9f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::lookup(unsigned long)
DHPEntry*
DBAMBPredictor::lookup(uint64_t signature)
{
	uint64_t set = indexFunction(signature);
	for(unsigned i = 0 ; i < m_RAP_assoc ; i++)
	{
		if(m_DHPTable[set][i]->signature == signature)
			return m_DHPTable[set][i];
	}
	return NULL;
}

// Assembly:
movl 0x338(%rdi), %ecx
testq %rcx, %rcx
je 0xe8f8
movl 0x33c(%rdi), %r8d
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movq 0x2e8(%rdi), %rax
leaq (%rdx,%rdx,2), %rdx
movq (%rax,%rdx,8), %rdx
xorl %edi, %edi
movq (%rdx,%rdi,8), %rax
cmpq %rsi, 0x20(%rax)
je 0xe8fa
incq %rdi
cmpl %edi, %ecx
jne 0xe8e7
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::computeRd(unsigned long, unsigned long, bool)
int
DBAMBPredictor::computeRd(uint64_t set, uint64_t  index , bool inNVM)
{
	vector<CacheEntry*> line;
	int ref_rd;
	
	if(inNVM){
		line = m_tableNVM[set];
		ref_rd = m_tableNVM[set][index]->policyInfo;
	}
	else{
		line = m_tableSRAM[set];
		ref_rd = m_tableSRAM[set][index]->policyInfo;
	}
	
	int position = 0;
	
	/* Determine the position of the cachel line in the LRU stack, the policyInfo is not enough */
	for(unsigned i = 0 ; i < line.size() ; i ++)
	{
		if(ref_rd < line[i]->policyInfo  && line[i]->isValid)
			position++;
	}
	return position;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testl %ecx, %ecx
je 0xfc3d
movq 0x10(%r15), %rax
leaq (%r14,%r14,2), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %rsp, %rdi
callq 0xc8b8
addq $0x10, %r15
jmp 0xfc58
movq 0x8(%r15), %rax
leaq (%r14,%r14,2), %rsi
shlq $0x3, %rsi
addq (%rax), %rsi
movq %rsp, %rdi
callq 0xc8b8
addq $0x8, %r15
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0xfc9d
sarq $0x3, %rax
movq (%r15), %rcx
movq (%rcx), %rcx
leaq (%r14,%r14,2), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx,%rbx,8), %rcx
movl 0x38(%rcx), %ecx
xorl %edx, %edx
xorl %ebx, %ebx
movq (%rdi,%rdx,8), %rsi
cmpl 0x38(%rsi), %ecx
jge 0xfc91
movzbl (%rsi), %esi
addl %esi, %ebx
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0xfc83
jmp 0xfc9f
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xfca9
callq 0x52a0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xfcc6
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::finishSimu()
void 
DBAMBPredictor::finishSimu()
{
	//DPRINTF("RAPPredictor::FINISH SIMU\n");

	if(simu_parameters.readDatasetFile || simu_parameters.writeDatasetFile)	
		firstAlloc_dataset_file.close();
	
	if(m_isWarmup)
		return;
		
	for(auto lines : m_DHPTable)
	{
		for(auto entry : lines)
		{		
			if(entry->isValid)
			{
				HistoEntry current = {entry->state_rw , entry->state_rd , entry->nbKeepState};
				entry->stats_history.push_back(current);

				if(entry->nbKeepState + entry->nbSwitchState  > 0)
					stats_nbSwitchDst.push_back((double)entry->nbSwitchState / \
					  (double) (entry->nbKeepState + entry->nbSwitchState) );
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x357ee(%rip), %rax     # 0x45f50
cmpb $0x0, 0x159(%rax)
jne 0x10774
cmpb $0x1, 0x15a(%rax)
jne 0x10780
leaq 0x350ed(%rip), %rdi     # 0x45868
callq 0x5070
cmpb $0x0, 0x81(%rbx)
jne 0x108ae
movq 0x2e8(%rbx), %r14
movq 0x2f0(%rbx), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r14
je 0x108ae
leaq 0x388(%rbx), %r15
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x1206c
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %rbp
cmpq %rbp, %r12
je 0x10890
movq (%r12), %r13
cmpb $0x1, 0x88(%r13)
jne 0x10887
movq 0x98(%r13), %rax
movq %rax, (%rsp)
movl 0x8c(%r13), %eax
movl %eax, 0x8(%rsp)
movq 0xa8(%r13), %rsi
cmpq 0xb0(%r13), %rsi
je 0x10820
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0xa8(%r13)
jmp 0x1082f
leaq 0xa0(%r13), %rdi
movq %rsp, %rdx
callq 0x12d6a
movl 0x90(%r13), %eax
movl 0x8c(%r13), %ecx
addl %eax, %ecx
jle 0x10887
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x390(%rbx), %rsi
cmpq 0x398(%rbx), %rsi
je 0x1087a
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x390(%rbx)
jmp 0x10887
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
callq 0x12ed6
addq $0x8, %r12
jmp 0x107c7
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1089f
callq 0x52a0
addq $0x18, %r14
cmpq 0x10(%rsp), %r14
jne 0x107b0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x108bf
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x108d1
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::openNewTimeFrame()
void 
DBAMBPredictor::openNewTimeFrame()
{ 

	if(m_isWarmup)
		return;

	stats_nbMigrationsFromNVM.push_back(vector<int>(2,0));
	dataset_file << "TimeFrame" << endl;
	Predictor::openNewTimeFrame();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0x81(%rdi)
jne 0x11ac7
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
xorl %r15d, %r15d
movq %r15, 0x10(%r14)
movl $0x8, %edi
callq 0x52e0
movq %rax, (%r14)
movq %rax, 0x8(%r14)
leaq 0x8(%rax), %rcx
movq %rcx, 0x10(%r14)
movq %r15, (%rax)
movq %rcx, 0x8(%r14)
leaq 0x3b8(%rbx), %rdi
movq %r14, %rsi
callq 0x1263c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x11a79
callq 0x52a0
leaq 0x33be8(%rip), %r14     # 0x45668
leaq 0x233c6(%rip), %rsi     # 0x34e4d
movl $0x9, %edx
movq %r14, %rdi
callq 0x5350
movq 0x33bcd(%rip), %rax     # 0x45668
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x52b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51f0
movq %rbx, %rdi
callq 0x27496
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x11ae2
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::hashingFunction(Access)
uint64_t
DBAMBPredictor::hashingFunction(Access element)
{	
	string total = buildHash( element.m_address , element.m_pc);
	string sig ="";
	for(unsigned i = 0 ; i < m_hashingBytes.size() ; i++)
	{
		assert(m_hashingBytes[i] < 16 && "Error on the hashing function bytes selection");
		sig += string(1, total[m_hashingBytes[i]]);
	}
	return hexToInt(sig);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0xc0(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x2ece5
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x24153(%rip), %rdx     # 0x35c7c
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0xccac
movq 0x340(%rbx), %rax
cmpq %rax, 0x348(%rbx)
je 0x11bc4
movl $0x1, %ebp
leaq 0x18(%rsp), %r13
xorl %ecx, %ecx
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
cmpl $0x10, (%rax,%rcx,4)
jge 0x11c37
movslq (%rax,%rcx,4), %rax
movq 0x68(%rsp), %rcx
movsbl (%rcx,%rax), %edx
movq %r13, 0x8(%rsp)
movl $0x1, %esi
movq %r14, %rdi
callq 0x5370
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x5100
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11ba6
callq 0x52a0
movl %ebp, %ecx
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x11b5c
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xcc1c
leaq 0x48(%rsp), %rdi
callq 0x2e768
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x11c00
callq 0x52a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x11c0f
callq 0x52a0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11c22
callq 0x52a0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23219(%rip), %rdi     # 0x34e57
leaq 0x22e27(%rip), %rsi     # 0x34a6c
leaq 0x23255(%rip), %rcx     # 0x34ea1
movl $0x3e3, %edx            # imm = 0x3E3
callq 0x51d0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
jne 0x11c7e
jmp 0x11c83
jmp 0x11c6c
movq %rax, %rbx
jmp 0x11c92
movq %rax, %rbx
jmp 0x11c83
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11c83
callq 0x52a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x11c92
callq 0x52a0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11ca5
callq 0x52a0
movq %rbx, %rdi
callq 0x55a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBLRUPolicy::evictPolicy(int)
int
DBAMBLRUPolicy::evictPolicy(int set)
{
	for(unsigned i = 0 ; i < m_assoc ; i++){
		if(!m_rap_entries[set][i]->isValid)
			return i;
	}
	
	int smallest_time = m_rap_entries[set][0]->policyInfo , smallest_index = 0;
	for(unsigned i = 0 ; i < m_assoc ; i++){
		if(m_rap_entries[set][i]->policyInfo < smallest_time){
			smallest_time =  m_rap_entries[set][i]->policyInfo;
			smallest_index = i;
		}
	}
	return smallest_index;
}

// Assembly:
movl 0x18(%rdi), %ecx
movslq %esi, %rdx
testq %rcx, %rcx
setne %r8b
je 0x11d82
movq 0x8(%rdi), %rax
movq (%rax), %rax
leaq (%rdx,%rdx,2), %rsi
movq (%rax,%rsi,8), %rsi
movq (%rsi), %r9
xorl %eax, %eax
cmpb $0x1, 0x88(%r9)
jne 0x11d7d
leaq -0x1(%rcx), %r8
xorl %eax, %eax
cmpq %rax, %r8
je 0x11d82
movq 0x8(%rsi,%rax,8), %r9
incq %rax
cmpb $0x1, 0x88(%r9)
je 0x11d5f
cmpq %rcx, %rax
setb %r8b
testb %r8b, %r8b
jne 0x11dba
testq %rcx, %rcx
je 0x11dbb
movq 0x8(%rdi), %rax
movq (%rax), %rax
leaq (%rdx,%rdx,2), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rdx), %rax
movl 0x2c(%rax), %esi
xorl %edi, %edi
xorl %eax, %eax
movq (%rdx,%rdi,8), %r8
movl 0x2c(%r8), %r8d
cmpl %esi, %r8d
cmovll %r8d, %esi
cmovll %edi, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0x11da0
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/DBAMBPredictor.hh
// Function: DHPEntry::initEntry(Access)
void initEntry(Access element) {
		 	cpts =  std::vector<int>(NUM_RW_TYPE,0);
		 	lastWrite = 0;
		 	signature = 0;
		 	des = ALLOCATE_PREEMPTIVELY;
		 	
		 	policyInfo = 0;
			cptBypassLearning = 0;
			rd_history.clear();
			rw_history.clear();
			nbAccess = 0;
			isValid = true;
			
			state_rw = RW_NOT_ACCURATE;
			state_rd = RD_NOT_ACCURATE;
			
			nbKeepCurrentState = 0;
			nbKeepState = 0;
			nbSwitchState = 0;
			cptWindow = 0;
			
			dead_counter = 0;
		 }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x14, %edi
callq 0x52e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq (%rbx), %rdi
movq %rax, (%rbx)
addq $0x14, %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
testq %rdi, %rdi
je 0x12123
callq 0x52a0
xorl %eax, %eax
movl %eax, 0x1c(%rbx)
movq $0x0, 0x20(%rbx)
movq $0x3, 0x28(%rbx)
movl %eax, 0x38(%rbx)
movq 0x40(%rbx), %rcx
cmpq %rcx, 0x48(%rbx)
je 0x12149
movq %rcx, 0x48(%rbx)
movq 0x58(%rbx), %rcx
movq %rcx, 0x68(%rbx)
movl %eax, 0x70(%rbx)
movq $0x0, 0x80(%rbx)
movb $0x1, 0x88(%rbx)
movl $0x2, 0x9c(%rbx)
movaps 0x22829(%rip), %xmm0    # 0x349a0
movups %xmm0, 0x8c(%rbx)
movl %eax, 0xb8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gvaumour[P]cache-simulator/src/Directory.cc
// Function: Directory::Directory()
Directory::Directory()
{
	m_nb_set = DIRECTORY_NB_SETS;
	m_assoc = DIRECTORY_ASSOC;

	//DPRINTF("DIRECTORY::Constructor , assoc=%d , m_nb_set=%d\n", m_assoc , m_nb_set);

	m_table.resize(m_nb_set);
	for(int i = 0  ; i < m_nb_set ; i++){
//		m_table[i].resize(m_assoc);
		m_table[i].clear();
		/*
		for(int j = 0 ; j < m_assoc ; j++){
			m_table[i][j] = new DirectoryEntry();
		}*/
	}
		
	m_policy = new DirectoryReplacementPolicy(m_assoc , m_nb_set , m_table);
	m_start_index = log2(BLOCK_SIZE)-1;
	m_end_index = log2(BLOCK_SIZE) + log2(m_nb_set);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x4000000800, %rax     # imm = 0x4000000800
movq %rax, 0x20(%rdi)
movl $0x800, %esi            # imm = 0x800
callq 0x13794
movslq 0x20(%rbx), %r14
testq %r14, %r14
jle 0x13012
movq (%rbx), %rax
leaq (,%r14,8), %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movq (%rax,%rdx), %rsi
cmpq %rsi, 0x8(%rax,%rdx)
je 0x13009
movq %rsi, 0x8(%rax,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x12ff9
movl $0x18, %edi
callq 0x52e0
movl 0x24(%rbx), %ecx
movl %ecx, 0x8(%rax)
movl %r14d, 0xc(%rax)
movq %rbx, 0x10(%rax)
movq $0x1, (%rax)
movq %rax, 0x18(%rbx)
movl $0x5, 0x2c(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
callq 0x55b0
addsd 0x21f17(%rip), %xmm0    # 0x34f68
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x13816
movq %r14, %rdi
callq 0x55a0
nop