LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x2200
movq -0x238(%rbp), %rdi
leaq 0x4120(%rip), %rsi      # 0x710b
movl $0x8, %edx
callq 0x2110
jmp 0x2ff7
jmp 0x2ff9
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x2310
movb %al, -0x241(%rbp)
jmp 0x3019
movb -0x241(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x302a
jmp 0x30ea
leaq -0x210(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x20f0
movq %rax, -0x250(%rbp)
jmp 0x3046
movq -0x250(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x2160
movq %rax, -0x258(%rbp)
jmp 0x3062
movq -0x258(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2160
jmp 0x3077
movq -0x240(%rbp), %rdi
addq $0x50, %rdi
leaq -0x220(%rbp), %rsi
callq 0x3750
jmp 0x3090
movq -0x240(%rbp), %rdi
addq $0x68, %rdi
leaq -0x228(%rbp), %rsi
callq 0x37c0
jmp 0x30a9
movq -0x240(%rbp), %rdi
subq $-0x80, %rdi
leaq -0x230(%rbp), %rsi
callq 0x37c0
jmp 0x30c2
jmp 0x2ff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2070
jmp 0x31dc
movq -0x240(%rbp), %rdi
addq $0x50, %rdi
callq 0x3830
movq %rax, %rcx
movq -0x240(%rbp), %rax
movl %ecx, 0x18(%rax)
movl 0x18(%rax), %esi
movq 0x7ec7(%rip), %rdi      # 0xafd8
callq 0x22c0
movq %rax, -0x260(%rbp)
jmp 0x311f
movq -0x260(%rbp), %rdi
leaq 0x40a9(%rip), %rsi      # 0x71d6
callq 0x21a0
movq %rax, -0x268(%rbp)
jmp 0x313b
movq -0x240(%rbp), %rdi
subq $-0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36e0
movq -0x268(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2320
movq %rax, -0x270(%rbp)
jmp 0x3168
movq -0x270(%rbp), %rdi
leaq 0x4060(%rip), %rsi      # 0x71d6
callq 0x21a0
movq %rax, -0x278(%rbp)
jmp 0x3184
movq -0x240(%rbp), %rdi
subq $-0x80, %rdi
movl $0x1, %esi
callq 0x36e0
movq -0x278(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2320
movq %rax, -0x280(%rbp)
jmp 0x31b2
movq -0x280(%rbp), %rdi
movq 0x7e08(%rip), %rsi      # 0xafc8
callq 0x21d0
jmp 0x31c7
leaq -0x210(%rbp), %rdi
callq 0x2070
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x22e0
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x58(%rbp)
movq %r9, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, -0x5c(%rbp)
callq 0x3830
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5062
movq -0x58(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x36c0
movq -0x48(%rbp), %rcx
movl (%rax), %eax
cltd
idivl 0x70(%rcx)
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x504e
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5041
movq -0x50(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x36e0
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5008
jmp 0x5043
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4ff9
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4fbc
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movq 0x3a6d(%rip), %rdi      # 0x4fe0
leaq 0x60(%rsp), %rsi
callq 0x1070
leaq 0x40(%rsp), %rdi
callq 0x1800
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x15df
movq 0x3a40(%rip), %rdi      # 0x4fe0
leaq 0x5c(%rsp), %rsi
callq 0x1070
jmp 0x15ac
leaq 0x40(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x1810
jmp 0x15bd
jmp 0x15bf
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x158f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1665
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1880
jmp 0x15f0
leaq 0x10(%rsp), %rdi
callq 0x1250
movl %eax, 0xc(%rsp)
jmp 0x1600
movl 0xc(%rsp), %esi
movq 0x39c5(%rip), %rdi      # 0x4fd0
callq 0x10f0
movq %rax, (%rsp)
jmp 0x1616
movq (%rsp), %rdi
movq 0x399f(%rip), %rsi      # 0x4fc0
callq 0x10c0
jmp 0x1628
leaq 0x10(%rsp), %rdi
callq 0x17a0
movl $0x0, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x17a0
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 0x17a0
leaq 0x40(%rsp), %rdi
callq 0x17a0
movq 0x30(%rsp), %rdi
callq 0x1100
nopl (%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x30(%rsp)
movss 0x24(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb7a6
movq 0x30(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq 0x78(%rsp), %rdi
callq 0xbff0
movq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xc040
jmp 0xb696
movq 0x30(%rsp), %rsi
addq $0x28, %rsi
leaq 0x70(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xc060
jmp 0xb6b0
leaq 0x78(%rsp), %rdi
callq 0xc420
movq %rax, 0x28(%rsp)
jmp 0xb6c1
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc450
leaq 0x78(%rsp), %rdi
callq 0xc4a0
movq %rax, 0x20(%rsp)
jmp 0xb6eb
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xc480
testb $0x1, %al
jne 0xb70d
jmp 0xb79c
callq 0xc4d0
movss %xmm0, 0x1c(%rsp)
jmp 0xb71a
movss 0x1c(%rsp), %xmm1
movq 0x30(%rsp), %rax
movss 0x24(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb78b
movq 0x30(%rsp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0xc530
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc4e0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0xb75d
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
jmp 0xb78b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xc580
jmp 0xb7ae
jmp 0xb78d
leaq 0x58(%rsp), %rdi
callq 0xc550
jmp 0xb6da
leaq 0x78(%rsp), %rdi
callq 0xc580
addq $0xd8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x6490
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/tree/./tree.h
// Function: state_t::onebits() const
unsigned onebits() const {
        unsigned count = 0;
        std::pair<unsigned, unsigned> b = branch();
        for( unsigned i = 0; i < 8 * sizeof(unsigned); ++i ) {
            count += b.first % 2;
            b.first = b.first >> 1;
            count += b.second % 2;
            b.second = b.second >> 1;
        }
        return count;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x0, 0xc(%rsp)
callq 0x118e0
movq %rax, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpq $0x20, %rax
jae 0x1098d
movl 0x4(%rsp), %eax
andl $0x1, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x4(%rsp), %eax
shrl %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
andl $0x1, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
shrl %eax
movl %eax, 0x8(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x10947
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: bonetblai[P]mdp-engine/tree/./tree.h
// Function: state_t::onerfwd(unsigned int)
void onerfwd(unsigned n) {
        if( depth() < n-1 ) {
            unsigned d = depth() + 1;
            data1_ = (d << 26) | branch1();
            if( depth() <= 32 )
                data2_ ^= (1 << (depth() - 1));
            else
                data1_ ^= (1 << (depth() - 33));
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x106c0
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x10bc2
movq 0x10(%rsp), %rdi
callq 0x106c0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
shll $0x1a, %eax
movl %eax, 0xc(%rsp)
callq 0x11950
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movl 0xc(%rsp), %eax
orl %ecx, %eax
movl %eax, (%rdi)
callq 0x106c0
cmpl $0x20, %eax
ja 0x10b9f
movq 0x10(%rsp), %rdi
callq 0x106c0
movl %eax, %ecx
movq 0x10(%rsp), %rax
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x10bc0
movq 0x10(%rsp), %rdi
callq 0x106c0
movl %eax, %ecx
movq 0x10(%rsp), %rax
subl $0x21, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x10bc2
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/tree/./tree.h
// Function: state_t::onebwd()
void onebwd() {
        if( depth() > 0 ) {
            if( depth() <= 32 )
                data2_ &= ~(1 << (depth() - 1));
            else
                data1_ &= ~(1 << (depth() - 33));
            unsigned d = depth() - 1;
            data1_ = (d << 26) | branch1();
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x106c0
cmpl $0x0, %eax
jbe 0x10c81
movq 0x10(%rsp), %rdi
callq 0x106c0
cmpl $0x20, %eax
ja 0x10c28
movq 0x10(%rsp), %rdi
callq 0x106c0
movl %eax, %ecx
movq 0x10(%rsp), %rax
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x10c4c
movq 0x10(%rsp), %rdi
callq 0x106c0
movl %eax, %ecx
movq 0x10(%rsp), %rax
subl $0x21, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl (%rax), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x106c0
movq 0x10(%rsp), %rdi
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
shll $0x1a, %eax
movl %eax, 0xc(%rsp)
callq 0x11950
movl 0xc(%rsp), %ecx
movl %eax, %edx
movq 0x10(%rsp), %rax
orl %edx, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x11950
movl %eax, %esi
leaq 0x74(%rsp), %rdi
callq 0x276c0
movq 0x58(%rsp), %rax
movl 0x4(%rax), %esi
leaq 0x70(%rsp), %rdi
callq 0x276c0
jmp 0x27556
movq 0x78(%rsp), %rdi
leaq 0x2b5e2(%rip), %rsi     # 0x52b44
callq 0x62b0
movq %rax, 0x50(%rsp)
jmp 0x2756e
movq 0x58(%rsp), %rdi
callq 0x106c0
movq 0x50(%rsp), %rdi
movl %eax, %esi
callq 0x63a0
movq %rax, 0x48(%rsp)
jmp 0x2758b
movq 0x48(%rsp), %rdi
leaq 0x2b5b0(%rip), %rsi     # 0x52b47
callq 0x62b0
movq %rax, 0x40(%rsp)
jmp 0x275a3
movq 0x58(%rsp), %rdi
callq 0x11950
movq 0x40(%rsp), %rdi
movl %eax, %esi
callq 0x63a0
movq %rax, 0x38(%rsp)
jmp 0x275c0
movq 0x38(%rsp), %rdi
leaq 0x2b580(%rip), %rsi     # 0x52b4c
callq 0x62b0
movq %rax, 0x30(%rsp)
jmp 0x275d8
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x63a0
movq %rax, 0x28(%rsp)
jmp 0x275f1
movq 0x28(%rsp), %rdi
leaq 0x2b551(%rip), %rsi     # 0x52b4e
callq 0x62b0
movq %rax, 0x20(%rsp)
jmp 0x27609
movq 0x20(%rsp), %rdi
leaq 0x74(%rsp), %rsi
callq 0x276e0
movq %rax, 0x18(%rsp)
jmp 0x2761f
movq 0x18(%rsp), %rdi
leaq 0x2b521(%rip), %rsi     # 0x52b4c
callq 0x62b0
movq %rax, 0x10(%rsp)
jmp 0x27637
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x276e0
movq %rax, 0x8(%rsp)
jmp 0x2764d
movq 0x8(%rsp), %rdi
leaq 0x2b4f8(%rip), %rsi     # 0x52b51
callq 0x62b0
jmp 0x27660
leaq 0x70(%rsp), %rdi
callq 0x27710
leaq 0x74(%rsp), %rdi
callq 0x27710
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x276a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x27710
leaq 0x74(%rsp), %rdi
callq 0x27710
movq 0x68(%rsp), %rdi
callq 0x6490
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1230
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1250
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x119b
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x1164
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::initFeatures()
void
CerebronPredictor::initFeatures()
{
	vector<string>* criterias_name = &m_criterias_names;
	vector<params_hash>* features_hash = &m_features_hash;
	vector<FeatureTable*>* features = &m_features;		

	for(auto feature : *criterias_name)
	{
		features->push_back( new FeatureTable(m_tableSize, feature, false));
		features_hash->push_back( parseFeatureName(feature) );
		/*
		if(feature == "CallStack" || feature == "CallStack1")
			m_need_callee_file = true;
		*/
	}	
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rax, %rcx
addq $0x2a0, %rcx            # imm = 0x2A0
movq %rcx, 0xf8(%rsp)
movq %rax, %rcx
addq $0x288, %rcx            # imm = 0x288
movq %rcx, 0xf0(%rsp)
addq $0x270, %rax            # imm = 0x270
movq %rax, 0xe8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xebf0
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xec20
movq %rax, 0xd0(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xec50
testb $0x1, %al
jne 0x7566
jmp 0x7738
leaq 0xd8(%rsp), %rdi
callq 0xec90
movq %rax, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x51b0
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0xa8, %edi
callq 0x53a0
movq %rax, 0x18(%rsp)
jmp 0x75a1
movq 0x20(%rsp), %rax
movb $0x1, 0x77(%rsp)
movl 0x2f0(%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x51b0
jmp 0x75c9
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2c870
jmp 0x75e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movb $0x0, 0x77(%rsp)
movq %rax, 0xa8(%rsp)
leaq 0xa8(%rsp), %rsi
callq 0xf750
jmp 0x7606
leaq 0x78(%rsp), %rdi
callq 0x5768
movq 0xf0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x51b0
jmp 0x7630
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7cd0
jmp 0x7646
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf780
jmp 0x7656
leaq 0x48(%rsp), %rdi
callq 0xf7b0
leaq 0x28(%rsp), %rdi
callq 0x5768
leaq 0xb0(%rsp), %rdi
callq 0x5768
leaq 0xd8(%rsp), %rdi
callq 0xeca0
jmp 0x7548
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x7729
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x76d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5768
testb $0x1, 0x77(%rsp)
jne 0x76df
jmp 0x76e9
movq 0x18(%rsp), %rdi
callq 0x5340
jmp 0x7729
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x771f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf7b0
leaq 0x28(%rsp), %rdi
callq 0x5768
leaq 0xb0(%rsp), %rdi
callq 0x5768
jmp 0x7740
addq $0x108, %rsp            # imm = 0x108
retq
movq 0xa0(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x10310
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x51b0
jmp 0x7d16
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x5f, %edx
callq 0x653b0
jmp 0x7d2c
leaq 0x30(%rsp), %rdi
callq 0x5768
xorl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0xfd00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5050
jmp 0x7d53
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0xfd00
movq %rax, %rdi
callq 0x51a0
movq %rax, %rdi
callq 0x55b0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x24(%rax)
leaq 0x50(%rsp), %rdi
callq 0xf190
cmpq $0x3, %rax
jne 0x7e0a
leaq 0x50(%rsp), %rdi
movl $0x2, %esi
callq 0xfd00
movq %rax, %rdi
leaq 0x6a911(%rip), %rsi     # 0x726b6
callq 0xfa60
movb %al, 0x7(%rsp)
jmp 0x7db0
movq 0x8(%rsp), %rax
movb 0x7(%rsp), %cl
andb $0x1, %cl
negb %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0x7e13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x7e40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5768
jmp 0x7e40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf560
jmp 0x7e40
movq 0x8(%rsp), %rax
movb $0x0, 0x20(%rax)
movb $0x1, 0x6f(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf560
testb $0x1, 0x6f(%rsp)
jne 0x7e33
movq 0x8(%rsp), %rdi
callq 0xf7b0
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0xf7b0
movq 0x28(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x10(%rax), %rsi
callq 0x573a0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x30(%rax), %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x56bc0
testb $0x1, %al
jne 0x7eab
jmp 0x7ed1
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x30(%rax), %rsi
movq 0x18(%rsp), %rax
movl %eax, %edx
callq 0x56510
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0xf7c0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x30(%rcx), %rdx
movq 0x10(%rcx), %rcx
movzbl %al, %esi
andl $0x1, %esi
callq 0x7f00
addq $0x28, %rsp
retq
nopl (%rax)
// File: gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::getDecision(CacheEntry*)
allocDecision 
CerebronPredictor::getDecision(CacheEntry* entry)
{
	if(simu_parameters.Cerebron_RDmodel)
	{
		if( entry->e_sram > entry->e_nvm )
			return ALLOCATE_IN_NVM;
		else 
			return ALLOCATE_IN_SRAM;
	}
	else
	{
		if( entry->cost_value > 0)
			return ALLOCATE_IN_SRAM;
		else
			return ALLOCATE_IN_NVM;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
leaq 0x87fbf(%rip), %rax     # 0x93ff0
testb $0x1, 0x226(%rax)
je 0xc068
movq -0x18(%rsp), %rax
movq 0x138(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x140(%rcx), %rax
jbe 0xc05e
movl $0x1, -0x4(%rsp)
jmp 0xc090
movl $0x0, -0x4(%rsp)
jmp 0xc090
movq -0x18(%rsp), %rax
movsd 0x130(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xc088
movl $0x0, -0x4(%rsp)
jmp 0xc090
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: gvaumour[P]cache-simulator/src/Cerebron.cc
// Function: CerebronPredictor::convertToAllocDecision(int, bool)
allocDecision
CerebronPredictor::convertToAllocDecision(int alloc_counter, bool isWrite)
{
	if(simu_parameters.Cerebron_lowConfidence)
	{
		
		if( abs(alloc_counter) < simu_parameters.perceptron_allocation_threshold )
		{
			if( isWrite )
				return ALLOCATE_IN_SRAM;
			else 
				return ALLOCATE_IN_NVM;
		}
		else
		{
			if( alloc_counter < 0 )
				return ALLOCATE_IN_SRAM;
			else
				return ALLOCATE_IN_NVM;
		}
	}
	else
	{
		if( alloc_counter < 0 )
			return ALLOCATE_IN_SRAM;
		else
			return ALLOCATE_IN_NVM;
	
	}
	
}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
andb $0x1, %al
movb %al, -0x15(%rsp)
leaq 0x87ef8(%rip), %rax     # 0x93ff0
testb $0x1, 0x221(%rax)
je 0xc151
movl -0x14(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
leaq 0x87edd(%rip), %rcx     # 0x93ff0
cmpl 0x1c0(%rcx), %eax
jge 0xc136
testb $0x1, -0x15(%rsp)
je 0xc12c
movl $0x0, -0x4(%rsp)
jmp 0xc16a
movl $0x1, -0x4(%rsp)
jmp 0xc16a
cmpl $0x0, -0x14(%rsp)
jge 0xc147
movl $0x0, -0x4(%rsp)
jmp 0xc16a
movl $0x1, -0x4(%rsp)
jmp 0xc16a
cmpl $0x0, -0x14(%rsp)
jge 0xc162
movl $0x0, -0x4(%rsp)
jmp 0xc16a
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x388, %rdi            # imm = 0x388
movq $0x0, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0xfb40
movq 0x8(%rsp), %rdi
addq $0x3a0, %rdi            # imm = 0x3A0
movq $0x0, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0xfb40
movq 0x8(%rsp), %rdi
addq $0x3b8, %rdi            # imm = 0x3B8
leaq 0x86101(%rip), %rsi     # 0x94240
callq 0xfb70
movq 0x8(%rsp), %rax
movq $0x0, 0x3d8(%rax)
movq $0x0, 0x3d0(%rax)
leaq 0x85e8a(%rip), %rax     # 0x93ff0
testb $0x1, 0x1cd(%rax)
je 0xe269
movq 0x8(%rsp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0xfbe0
cmpq $0x0, %rax
je 0xe267
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %eax
movq %rax, (%rsp)
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0xfbe0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xe1f8
movq 0x8(%rsp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0xfc00
movsd (%rax), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xe19f
movq 0x8(%rsp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0xfbe0
movq 0x8(%rsp), %rdi
movq %rax, %xmm1
movaps 0x62df6(%rip), %xmm0    # 0x71010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x62dfa(%rip), %xmm0    # 0x71020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
addq $0x3f8, %rdi            # imm = 0x3F8
leaq 0x38(%rsp), %rsi
callq 0xfc20
movq 0x8(%rsp), %rdi
addq $0x3e0, %rdi            # imm = 0x3E0
callq 0xfc90
jmp 0xe269
movq 0x8(%rsp), %rax
addq $0x270, %rax            # imm = 0x270
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf680
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf6b0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf6e0
testb $0x1, %al
jne 0xe2ac
jmp 0xe2d4
leaq 0x20(%rsp), %rdi
callq 0xf720
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2d6a0
leaq 0x20(%rsp), %rdi
callq 0xf730
jmp 0xe297
movq 0x8(%rsp), %rdi
callq 0x56dc0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x77eb6(%rip), %rcx     # 0x92620
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x2e8, %rax            # imm = 0x2E8
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x20610
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x20640
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20670
testb $0x1, %al
jne 0x1a7b2
jmp 0x1a862
leaq 0x50(%rsp), %rdi
callq 0x206b0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x206c0
jmp 0x1a7cb
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x207c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x207f0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x20820
testb $0x1, %al
jne 0x1a808
jmp 0x1a849
leaq 0x20(%rsp), %rdi
callq 0x20860
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1a83b
movq (%rsp), %rdi
callq 0x20870
movq (%rsp), %rdi
callq 0x5340
jmp 0x1a83d
leaq 0x20(%rsp), %rdi
callq 0x208c0
jmp 0x1a7f3
leaq 0x30(%rsp), %rdi
callq 0x208e0
leaq 0x50(%rsp), %rdi
callq 0x20940
jmp 0x1a79a
leaq 0x79787(%rip), %rax     # 0x93ff0
testb $0x1, (%rax)
je 0x1a87e
leaq 0x78e93(%rip), %rdi     # 0x93708
callq 0x5550
jmp 0x1a87c
jmp 0x1a87e
movq 0x8(%rsp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x20540
movq 0x8(%rsp), %rdi
addq $0x3b8, %rdi            # imm = 0x3B8
callq 0xee90
movq 0x8(%rsp), %rdi
addq $0x3a0, %rdi            # imm = 0x3A0
callq 0xee90
movq 0x8(%rsp), %rdi
addq $0x388, %rdi            # imm = 0x388
callq 0xf460
movq 0x8(%rsp), %rdi
addq $0x340, %rdi            # imm = 0x340
callq 0xef00
movq 0x8(%rsp), %rdi
addq $0x308, %rdi            # imm = 0x308
callq 0x205a0
movq 0x8(%rsp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x205b0
movq 0x8(%rsp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
callq 0xf520
movq 0x8(%rsp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x5768
movq 0x8(%rsp), %rdi
callq 0x549b0
addq $0x68, %rsp
retq
movq %rax, %rdi
callq 0x10690
nop
// File: gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::hashingSignature(Access)
uint64_t
DBAMBPredictor::hashingSignature(Access element)
{
	if(m_hashingBytes.size() != 0)
	{			
		return hashingFunction(element);		
	}
	else if(simu_parameters.DBAMB_signature == "first_pc")
	{
		return bitSelect( element.m_pc, simu_parameters.DBAMB_begin_bit , simu_parameters.DBAMB_end_bit);
	}
	else if(simu_parameters.DBAMB_signature == "addr")
	{
		return bitSelect(element.m_address , simu_parameters.DBAMB_begin_bit , simu_parameters.DBAMB_end_bit);
	}
	assert(true && "Wrong hashing signature parameter\n");
	return 0;
}

// Assembly:
subq $0x98, %rsp
leaq 0xa0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x48(%rsp)
addq $0x340, %rdi            # imm = 0x340
callq 0x11020
cmpq $0x0, %rax
je 0x1b07f
movq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x38, %edx
callq 0x52f0
movq 0x48(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x50(%rsp), %xmm0
movups 0x60(%rsp), %xmm1
movups 0x70(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1fc30
movq %rax, 0x90(%rsp)
jmp 0x1b132
leaq 0x78f6a(%rip), %rdi     # 0x93ff0
addq $0x130, %rdi            # imm = 0x130
leaq 0x56e3c(%rip), %rsi     # 0x71ed0
callq 0xfa60
testb $0x1, %al
jne 0x1b09f
jmp 0x1b0d1
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x78f41(%rip), %rax     # 0x93ff0
movl 0x150(%rax), %esi
leaq 0x78f34(%rip), %rax     # 0x93ff0
movl 0x154(%rax), %edx
callq 0x65540
movq %rax, 0x90(%rsp)
jmp 0x1b132
leaq 0x78f18(%rip), %rdi     # 0x93ff0
addq $0x130, %rdi            # imm = 0x130
leaq 0x56df3(%rip), %rsi     # 0x71ed9
callq 0xfa60
testb $0x1, %al
jne 0x1b0f1
jmp 0x1b122
movq 0x40(%rsp), %rax
movq (%rax), %rdi
leaq 0x78ef0(%rip), %rax     # 0x93ff0
movl 0x150(%rax), %esi
leaq 0x78ee3(%rip), %rax     # 0x93ff0
movl 0x154(%rax), %edx
callq 0x65540
movq %rax, 0x90(%rsp)
jmp 0x1b132
jmp 0x1b124
jmp 0x1b126
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x1b220
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x338(%rcx), %eax
jae 0x1b1ff
movq 0x8(%rsp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
movq 0x18(%rsp), %rsi
callq 0x20270
movq %rax, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x20430
movq (%rax), %rax
movq 0x20(%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x1b1f0
movq 0x8(%rsp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
movq 0x18(%rsp), %rsi
callq 0x20270
movq %rax, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x20430
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1b208
jmp 0x1b1f2
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1b17f
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfe30
testb $0x1, 0x5f(%rsp)
je 0x1cec1
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xf9a0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0xfe40
jmp 0x1ce78
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, 0x3c(%rsp)
jmp 0x1cf0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x10120
jmp 0x1cfb1
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xf9a0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0xfe40
jmp 0x1cee3
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xf9a0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0xf9c0
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, 0x3c(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x10100
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1cf96
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xf9c0
movq %rax, %rcx
movl 0xc(%rsp), %eax
movq (%rcx), %rcx
cmpl 0x38(%rcx), %eax
jge 0x1cf87
movl 0x24(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xf9c0
movq (%rax), %rax
testb $0x1, (%rax)
je 0x1cf87
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1cf89
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1cf1d
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x10120
movl 0x8(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5690
nopl (%rax,%rax)
// File: gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::convertRD(int)
RD_TYPE
DBAMBPredictor::convertRD(int rd)
{

	if(simu_parameters.sram_assoc <= simu_parameters.nvm_assoc)
	{	
		if(rd < simu_parameters.sram_assoc)
			return RD_SHORT;
		else if(rd < simu_parameters.nvm_assoc)
			return RD_MEDIUM;
		else 
			return RD_NOT_ACCURATE;
	}
	else
	{
		if(rd < simu_parameters.nvm_assoc)
			return RD_SHORT;
		else if(rd < simu_parameters.sram_assoc)
			return RD_MEDIUM;
		else 
			return RD_NOT_ACCURATE;
	
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
leaq 0x77020(%rip), %rax     # 0x93ff0
movl 0x38(%rax), %eax
leaq 0x77016(%rip), %rcx     # 0x93ff0
cmpl 0x40(%rcx), %eax
jg 0x1d01d
movl -0x14(%rsp), %eax
leaq 0x77006(%rip), %rcx     # 0x93ff0
cmpl 0x38(%rcx), %eax
jge 0x1cff9
movl $0x0, -0x4(%rsp)
jmp 0x1d059
movl -0x14(%rsp), %eax
leaq 0x76fec(%rip), %rcx     # 0x93ff0
cmpl 0x40(%rcx), %eax
jge 0x1d013
movl $0x1, -0x4(%rsp)
jmp 0x1d059
movl $0x2, -0x4(%rsp)
jmp 0x1d059
movl -0x14(%rsp), %eax
leaq 0x76fc8(%rip), %rcx     # 0x93ff0
cmpl 0x40(%rcx), %eax
jge 0x1d037
movl $0x0, -0x4(%rsp)
jmp 0x1d059
movl -0x14(%rsp), %eax
leaq 0x76fae(%rip), %rcx     # 0x93ff0
cmpl 0x38(%rcx), %eax
jge 0x1d051
movl $0x1, -0x4(%rsp)
jmp 0x1d059
movl $0x2, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: gvaumour[P]cache-simulator/src/DBAMBPredictor.cc
// Function: DBAMBPredictor::convertState(DHPEntry*)
allocDecision
DBAMBPredictor::convertState(DHPEntry* rap_current)
{
	RD_TYPE state_rd = rap_current->state_rd;
	RW_TYPE state_rw = rap_current->state_rw;

	if(state_rw == RO)
	{
		if(simu_parameters.sram_assoc <= simu_parameters.nvm_assoc)
		{
			return ALLOCATE_IN_NVM;	
		}
		else
		{
			if(state_rd == RD_SHORT || state_rd == RD_NOT_ACCURATE)
				return ALLOCATE_IN_NVM;
			else if(state_rd == RD_MEDIUM)
				return ALLOCATE_IN_SRAM;
			else 
				return BYPASS_CACHE;		
		}
		
	}
	else if(state_rw == RW || state_rw == WO)
	{
	
		if(simu_parameters.sram_assoc <= simu_parameters.nvm_assoc)
		{
			if(state_rd == RD_SHORT || state_rd == RD_NOT_ACCURATE)
				return ALLOCATE_IN_SRAM;
			else if(state_rd == RD_MEDIUM)
				return ALLOCATE_IN_NVM;
			else 
				return BYPASS_CACHE;		
		}
		else
		{
			return ALLOCATE_IN_SRAM;		
		}
	}
	else if(state_rw == DEAD)
	{
		// When in dead state, rd state is always innacurate, no infos 
		if(rap_current->des == ALLOCATE_IN_SRAM)
			return ALLOCATE_IN_NVM;
		else 
			return BYPASS_CACHE;	
	}
	else
	{ // State RW not accurate 
	
		if(state_rd == RD_SHORT)
			return ALLOCATE_IN_SRAM;
		else if( state_rd == RD_MEDIUM)
			return ALLOCATE_IN_NVM;
		else if(state_rd == RD_NOT_ACCURATE) // We don't know anything for sure, go preemptive
			return ALLOCATE_PREEMPTIVELY;
		else 
			return BYPASS_CACHE;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl 0x9c(%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl 0x98(%rax), %eax
movl %eax, -0x20(%rsp)
cmpl $0x2, -0x20(%rsp)
jne 0x1e3ce
leaq 0x75c7a(%rip), %rax     # 0x93ff0
movl 0x38(%rax), %eax
leaq 0x75c70(%rip), %rcx     # 0x93ff0
cmpl 0x40(%rcx), %eax
jg 0x1e392
movl $0x1, -0x4(%rsp)
jmp 0x1e493
cmpl $0x0, -0x1c(%rsp)
je 0x1e3a0
cmpl $0x2, -0x1c(%rsp)
jne 0x1e3ad
movl $0x1, -0x4(%rsp)
jmp 0x1e493
cmpl $0x1, -0x1c(%rsp)
jne 0x1e3c1
movl $0x0, -0x4(%rsp)
jmp 0x1e493
movl $0x2, -0x4(%rsp)
jmp 0x1e493
cmpl $0x3, -0x20(%rsp)
je 0x1e3dc
cmpl $0x1, -0x20(%rsp)
jne 0x1e432
leaq 0x75c0d(%rip), %rax     # 0x93ff0
movl 0x38(%rax), %eax
leaq 0x75c03(%rip), %rcx     # 0x93ff0
cmpl 0x40(%rcx), %eax
jg 0x1e428
cmpl $0x0, -0x1c(%rsp)
je 0x1e400
cmpl $0x2, -0x1c(%rsp)
jne 0x1e40d
movl $0x0, -0x4(%rsp)
jmp 0x1e493
cmpl $0x1, -0x1c(%rsp)
jne 0x1e41e
movl $0x1, -0x4(%rsp)
jmp 0x1e493
movl $0x2, -0x4(%rsp)
jmp 0x1e493
movl $0x0, -0x4(%rsp)
jmp 0x1e493
cmpl $0x0, -0x20(%rsp)
jne 0x1e458
movq -0x18(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x1e44e
movl $0x1, -0x4(%rsp)
jmp 0x1e493
movl $0x2, -0x4(%rsp)
jmp 0x1e493
cmpl $0x0, -0x1c(%rsp)
jne 0x1e469
movl $0x0, -0x4(%rsp)
jmp 0x1e493
cmpl $0x1, -0x1c(%rsp)
jne 0x1e47a
movl $0x1, -0x4(%rsp)
jmp 0x1e493
cmpl $0x2, -0x1c(%rsp)
jne 0x1e48b
movl $0x3, -0x4(%rsp)
jmp 0x1e493
movl $0x2, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
leaq 0x75b2e(%rip), %rax     # 0x93ff0
testb $0x1, 0x159(%rax)
jne 0x1e4db
leaq 0x75b1e(%rip), %rax     # 0x93ff0
testb $0x1, 0x15a(%rax)
je 0x1e4e7
leaq 0x75426(%rip), %rdi     # 0x93908
callq 0x5080
movq (%rsp), %rax
testb $0x1, 0x81(%rax)
je 0x1e4f9
jmp 0x1e69d
movq (%rsp), %rax
addq $0x2e8, %rax            # imm = 0x2E8
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x20610
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x20640
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x20670
testb $0x1, %al
jne 0x1e53e
jmp 0x1e69d
leaq 0x70(%rsp), %rdi
callq 0x206b0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x206c0
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x207c0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x207f0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x20820
testb $0x1, %al
jne 0x1e595
jmp 0x1e684
leaq 0x40(%rsp), %rdi
callq 0x20860
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x88(%rax)
je 0x1e673
movq 0x30(%rsp), %rax
movl 0x98(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movl 0x9c(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x8c(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
addq $0xa0, %rdi
leaq 0x24(%rsp), %rsi
callq 0x20d50
jmp 0x1e5fe
movq 0x30(%rsp), %rax
movl 0x8c(%rax), %eax
movq 0x30(%rsp), %rcx
addl 0x90(%rcx), %eax
cmpl $0x0, %eax
jle 0x1e671
movq (%rsp), %rdi
addq $0x388, %rdi            # imm = 0x388
movq 0x30(%rsp), %rcx
movl 0x8c(%rcx), %eax
movl 0x90(%rcx), %ecx
cvtsi2sd %ecx, %xmm0
addl %ecx, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x20dc0
jmp 0x1e655
jmp 0x1e671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x208e0
jmp 0x1e6a5
jmp 0x1e673
jmp 0x1e675
leaq 0x40(%rsp), %rdi
callq 0x208c0
jmp 0x1e57d
leaq 0x50(%rsp), %rdi
callq 0x208e0
leaq 0x70(%rsp), %rdi
callq 0x20940
jmp 0x1e526
addq $0x88, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5690
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x81(%rax)
je 0x1fb51
jmp 0x1fbe4
movq 0x18(%rsp), %rax
addq $0x3b8, %rax            # imm = 0x3B8
movq %rax, 0x8(%rsp)
movl $0x0, 0x34(%rsp)
leaq 0x33(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xed30
movq 0x10(%rsp), %rcx
leaq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x34(%rsp), %rdx
callq 0xed40
jmp 0x1fb93
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x20510
jmp 0x1fba4
leaq 0x38(%rsp), %rdi
callq 0xef00
leaq 0x33(%rsp), %rdi
callq 0xef60
leaq 0x73b49(%rip), %rdi     # 0x93708
leaq 0x52257(%rip), %rsi     # 0x71e1d
callq 0x5380
movq %rax, %rdi
movq 0x733e3(%rip), %rsi     # 0x92fb8
callq 0x53d0
movq 0x18(%rsp), %rdi
callq 0x56dc0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1fc11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xef00
leaq 0x33(%rsp), %rdi
callq 0xef60
movq 0x28(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xe8, %rsp
leaq 0xf0(%rsp), %rax
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq (%rax), %rsi
movq 0x10(%rax), %rdx
leaq 0xc0(%rsp), %rdi
callq 0x65ce0
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x56a0
movq 0x38(%rsp), %rdx
leaq 0x52fde(%rip), %rsi     # 0x72c64
leaq 0xa0(%rsp), %rdi
callq 0x5530
jmp 0x1fc95
leaq 0x9f(%rsp), %rdi
callq 0x53e0
movl $0x0, 0x88(%rsp)
movq 0x30(%rsp), %rdi
movl 0x88(%rsp), %eax
movq %rax, 0x28(%rsp)
addq $0x340, %rdi            # imm = 0x340
callq 0x11020
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x1fe59
movq 0x30(%rsp), %rdi
addq $0x340, %rdi            # imm = 0x340
movl 0x88(%rsp), %eax
movl %eax, %esi
callq 0xef90
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x10, (%rcx)
movb %al, 0x27(%rsp)
jge 0x1fd0b
movb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x1fd0b
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x1fd15
jmp 0x1fd17
jmp 0x1fd5c
leaq 0x52137(%rip), %rdi     # 0x71e55
leaq 0x51d17(%rip), %rsi     # 0x71a3c
movl $0x3e3, %edx            # imm = 0x3E3
leaq 0x5216e(%rip), %rcx     # 0x71e9f
callq 0x5260
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x9f(%rsp), %rdi
callq 0x53e0
jmp 0x1fed8
movq 0x30(%rsp), %rdi
addq $0x340, %rdi            # imm = 0x340
movl 0x88(%rsp), %eax
movl %eax, %esi
callq 0xef90
movslq (%rax), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x5750
movq %rax, 0x18(%rsp)
jmp 0x1fd8d
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56a0
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
leaq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x5270
jmp 0x1fdc2
leaq 0xa0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x54f0
jmp 0x1fdd6
leaq 0x68(%rsp), %rdi
callq 0x5768
leaq 0x67(%rsp), %rdi
callq 0x53e0
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x1fcad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1fecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1fe4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5768
leaq 0x67(%rsp), %rdi
callq 0x53e0
jmp 0x1fecb
leaq 0x40(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x51b0
jmp 0x1fe6d
leaq 0x40(%rsp), %rdi
callq 0x656a0
movq %rax, (%rsp)
jmp 0x1fe7d
leaq 0x40(%rsp), %rdi
callq 0x5768
leaq 0xa0(%rsp), %rdi
callq 0x5768
leaq 0xc0(%rsp), %rdi
callq 0x5768
movq (%rsp), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5768
leaq 0xa0(%rsp), %rdi
callq 0x5768
leaq 0xc0(%rsp), %rdi
callq 0x5768
movq 0x90(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x18(%rcx), %eax
jae 0x200b6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x24(%rsp), %rsi
callq 0x20270
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x20430
movq (%rax), %rax
testb $0x1, 0x88(%rax)
jne 0x200a7
movl 0x20(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x20174
jmp 0x200a9
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2005f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x24(%rsp), %rsi
callq 0x20270
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20430
movq (%rax), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x18(%rcx), %eax
jae 0x2016c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x24(%rsp), %rsi
callq 0x20270
movq %rax, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x20430
movq (%rax), %rax
movl 0x2c(%rax), %eax
cmpl 0x1c(%rsp), %eax
jge 0x2015d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movslq 0x24(%rsp), %rsi
callq 0x20270
movq %rax, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x20430
movq (%rax), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x2015f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x200ef
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)