LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/./mappedHeap.hpp
// Function: MappedHeap<InfCost<int>>::up_heap(int)
int MappedHeap<CompareLess>::up_heap(int k) {
	while (k > 1) {
		int p = k / 2;
		if (compLess(heap[p], heap[k])) {
			swap(position[heap[p]], position[heap[k]]);
			swap(heap[p], heap[k]);
		}
		k = p;
	}
	return k;
}

// Assembly:
movl %esi, %eax
cmpl $0x2, %esi
jl 0xbdbd
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x38(%rdi), %rsi
movl %eax, %edi
shrl %eax
movslq (%rcx,%rax,4), %r8
movl (%rsi,%r8,4), %r10d
movslq (%rcx,%rdi,4), %r9
cmpl (%rsi,%r9,4), %r10d
jge 0xbdb8
movl (%rdx,%r8,4), %r10d
movl (%rdx,%r9,4), %r11d
movl %r11d, (%rdx,%r8,4)
movl %r10d, (%rdx,%r9,4)
movl (%rcx,%rax,4), %r8d
movl (%rcx,%rdi,4), %r9d
movl %r9d, (%rcx,%rax,4)
movl %r8d, (%rcx,%rdi,4)
cmpl $0x3, %edi
ja 0xbd82
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/Utilities.cpp
// Function: Utilities::computeMinimumDistance(double, double, double, double, char)
double Utilities::computeMinimumDistance(double lat1, double lon1, double lat2, double lon2, char unit){
    double R = 6371; // Radius of the earth in km
    double dLat = deg2rad(lat2-lat1);  // deg2rad below
    double dLon = deg2rad(lon2-lon1); 
    double a = sin(dLat/2) * sin(dLat/2) + cos(deg2rad(lat1)) * cos(deg2rad(lat2)) * sin(dLon/2) * sin(dLon/2); 
    double c = 2 * atan2(sqrt(a), sqrt(1-a)); 
    double d = R * c; // Distance in km
    return d;
}

// Assembly:
subq $0x28, %rsp
movapd %xmm2, %xmm4
movsd %xmm2, (%rsp)
movsd %xmm0, 0x18(%rsp)
subsd %xmm0, %xmm4
movsd 0xba55(%rip), %xmm0     # 0x18540
mulsd %xmm0, %xmm4
movsd 0xba51(%rip), %xmm2     # 0x18548
divsd %xmm2, %xmm4
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rsp)
mulsd 0xba3b(%rip), %xmm4     # 0x18550
movsd %xmm4, 0x8(%rsp)
movapd %xmm4, %xmm0
callq 0x30c0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x30c0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0xb9f7(%rip), %xmm0     # 0x18540
divsd 0xb9f7(%rip), %xmm0     # 0x18548
callq 0x3630
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
mulsd 0xb9d7(%rip), %xmm0     # 0x18540
divsd 0xb9d7(%rip), %xmm0     # 0x18548
callq 0x3630
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0xb9c1(%rip), %xmm0     # 0x18550
movsd %xmm0, 0x10(%rsp)
callq 0x30c0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x30c0
movsd 0x8(%rsp), %xmm1
mulsd (%rsp), %xmm0
mulsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jb 0xcbd7
xorps %xmm2, %xmm2
sqrtsd %xmm1, %xmm2
jmp 0xcbf4
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x32c0
xorpd %xmm3, %xmm3
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0xb474(%rip), %xmm0     # 0x18070
subsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0xcc0f
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xcc24
movsd %xmm2, 0x10(%rsp)
callq 0x32c0
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x3080
addsd %xmm0, %xmm0
mulsd 0xb91f(%rip), %xmm0     # 0x18558
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/Locations.cpp
// Function: Locations::same_location(int, int)
bool Locations::same_location(int id1, int id2){
    pair <double, double> coord1;
    vector<int> users_list;

    get_coordinates(id1, coord1);
    users_list = *get_users(coord1);
    for (int i = 0; i < users_list.size(); ++i){
        if (users_list[i] == id2)
            return true;
    }
    return false;

}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rdi), %rcx
movslq %esi, %rdx
movq (%rcx,%rdx,8), %rcx
movups (%rcx), %xmm0
movaps %xmm0, (%rax)
addq $0x10, %rdi
movq %rax, %rsi
callq 0xd058
movq %rsp, %rdi
movq %rax, %rsi
callq 0xa78e
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
setne %bpl
je 0xd021
sarq $0x2, %rax
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
cmpl %ebx, (%rdi)
je 0xd021
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rcx
je 0xd01a
leaq 0x1(%rdx), %rsi
cmpl %ebx, (%rdi,%rdx,4)
jne 0xd009
cmpq %rdx, %rax
seta %bpl
testq %rdi, %rdi
je 0xd02b
callq 0x3340
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd045
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::BinaryHeap(int)
BinaryHeap::BinaryHeap(int numItems){
	size = numItems;
	distances = new double[size];
	vertices = new int[size];
	for (int i = 0; i < size; ++i){
		distances[i] = numeric_limits<double>::max();
		vertices[i] = 0;
	}

	for (int i = parent(size - 1); i >= 0; --i){
		hipify(i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movslq %esi, %rax
leaq (,%rax,8), %rdi
testl %eax, %eax
movq $-0x1, %rcx
cmovsq %rcx, %rdi
leaq (,%rax,4), %r15
cmovsq %rcx, %r15
callq 0x3030
movq %rax, %r14
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
movslq 0x10(%rbx), %r15
testq %r15, %r15
jle 0xd692
leaq (,%r15,4), %rdx
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
callq 0x31c0
leal 0x1(%r15), %eax
leaq -0x1(%r15), %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %eax
shlq $0x4, %rax
movdqa 0xaa05(%rip), %xmm1     # 0x18020
movdqa 0xaa0d(%rip), %xmm2     # 0x18030
pxor %xmm2, %xmm0
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
pcmpeqd %xmm3, %xmm3
movdqa 0xb053(%rip), %xmm4     # 0x18690
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0xd672
movq %rcx, (%r14,%r12)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0xd685
movq %rcx, 0x8(%r14,%r12)
paddq %xmm4, %xmm1
addq $0x10, %r12
cmpq %r12, %rax
jne 0xd63d
testl %r15d, %r15d
jle 0xd6c2
movl %r15d, %eax
addl $-0x2, %eax
shrl $0x1f, %eax
leal (%r15,%rax), %r14d
addl $-0x2, %r14d
sarl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0xd6dc
leal -0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
jg 0xd6ab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::swap(int, int)
void BinaryHeap::swap(int idx1, int idx2){
	double tempDist = distances[idx1];
	int tempVert = vertices[idx1];
	distances[idx1] = distances[idx2];
	vertices[idx1] = vertices[idx2];
	distances[idx2] = tempDist;
	vertices[idx2] = tempVert;
}

// Assembly:
movslq %esi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rsi
movsd (%rcx,%rax,8), %xmm0
movl (%rsi,%rax,4), %edi
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm1
movsd %xmm1, (%rcx,%rax,8)
movl (%rsi,%rdx,4), %r8d
movl %r8d, (%rsi,%rax,4)
movsd %xmm0, (%rcx,%rdx,8)
movl %edi, (%rsi,%rdx,4)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::percolate(int)
void BinaryHeap::percolate(int idx){
	int curr = idx;
	int p = parent(idx);
	while (curr > 0 && priority(p) < priority(curr)){
		swap(p, curr);
		curr = p;
		p = parent(curr);
	}
}

// Assembly:
testl %esi, %esi
jle 0xd801
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leal -0x1(%rsi), %edi
shrl $0x1f, %edi
movl %esi, %edx
addl %edi, %esi
decl %esi
sarl %esi
movslq %esi, %rdi
movsd (%rax,%rdi,8), %xmm0
movsd (%rax,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd801
movl (%rcx,%rdi,4), %r8d
movsd %xmm1, (%rax,%rdi,8)
movl (%rcx,%rdx,4), %r9d
movl %r9d, (%rcx,%rdi,4)
movsd %xmm0, (%rax,%rdx,8)
movl %r8d, (%rcx,%rdx,4)
cmpl $0x2, %edx
jg 0xd7c1
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::popMax()
void BinaryHeap::popMax(){
	distances[0] = -1;
	vertices[0] = -1;
	swap(0, size - 1);
	--size;
	hipify(0);
}

// Assembly:
movq (%rdi), %rax
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, (%rax)
movq 0x8(%rdi), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %esi, (%rdx)
movslq 0x10(%rdi), %r8
movsd -0x8(%rax,%r8,8), %xmm0
movsd %xmm0, (%rax)
movl -0x4(%rdx,%r8,4), %r9d
movl %r9d, (%rdx)
movq %rcx, -0x8(%rax,%r8,8)
movl %esi, -0x4(%rdx,%r8,4)
decl 0x10(%rdi)
xorl %esi, %esi
jmp 0xd6dc
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/BinaryHeap.cc
// Function: BinaryHeap::print()
void BinaryHeap::print(){
	cout << "[";
	for (int i = 0; i < size; ++i){
		cout << "(" << distances[i] << ", " << vertices[i] << "), ";
	}
	cout << "]" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x11723(%rip), %rdi     # 0x1efd0
leaq 0xadec(%rip), %rsi      # 0x186a0
movl $0x1, %edx
callq 0x33b0
cmpl $0x0, 0x10(%r14)
jle 0xd941
xorl %r12d, %r12d
movq 0x11701(%rip), %r15     # 0x1efd0
leaq 0xadcd(%rip), %r13      # 0x186a3
leaq 0xadc5(%rip), %rbp      # 0x186a2
movl $0x1, %edx
movq %r15, %rdi
leaq 0xa9d8(%rip), %rsi      # 0x182c4
callq 0x33b0
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %r15, %rdi
callq 0x3520
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x33b0
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x35b0
movl $0x3, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x33b0
incq %r12
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jl 0xd8dd
leaq 0xa7cd(%rip), %rsi      # 0x18115
movl $0x1, %edx
movq 0x1167c(%rip), %rbx     # 0x1efd0
movq %rbx, %rdi
callq 0x33b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3240
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::~Graph()
Graph::~Graph(){
    delete [] seedSets;
    delete [] seedSets_before;
    for (int p = 0; p < numEvents; ++p){
        delete [] AP[p];
    }
    delete [] AP;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xad0(%rdi), %r15
testq %r15, %r15
je 0xe5dd
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xe5d5
addq $-0x30, %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
leaq (%r15,%r12), %rdi
callq 0x12cfe
addq $-0x30, %r12
jne 0xe5c6
movq %r14, %rdi
callq 0x3410
movq 0xad8(%rbx), %r15
testq %r15, %r15
je 0xe619
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xe611
addq $-0x30, %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
leaq (%r15,%r12), %rdi
callq 0x12cfe
addq $-0x30, %r12
jne 0xe602
movq %r14, %rdi
callq 0x3410
cmpl $0x0, 0x9d0(%rbx)
jle 0xe649
xorl %r14d, %r14d
movq 0xb18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xe63a
callq 0x3410
incq %r14
movslq 0x9d0(%rbx), %rax
cmpq %rax, %r14
jl 0xe625
movq 0xb18(%rbx), %rdi
testq %rdi, %rdi
je 0xe65a
callq 0x3410
movq 0xb00(%rbx), %rdi
testq %rdi, %rdi
je 0xe66b
callq 0x3340
leaq 0xae0(%rbx), %rdi
callq 0x128d8
movq 0xab8(%rbx), %rdi
testq %rdi, %rdi
je 0xe688
callq 0x3340
leaq 0xaa0(%rbx), %rdi
callq 0x12918
leaq 0xa88(%rbx), %rdi
callq 0xaf12
movq 0xa70(%rbx), %rdi
testq %rdi, %rdi
je 0xe6b1
callq 0x3340
leaq 0xa38(%rbx), %rdi
callq 0xb4c2
movq 0xa20(%rbx), %rdi
testq %rdi, %rdi
je 0xe6ce
callq 0x3340
leaq 0xa08(%rbx), %rdi
callq 0x12918
leaq 0x9f0(%rbx), %rdi
callq 0x12918
addq $0x9d8, %rbx            # imm = 0x9D8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaf12
movq %rax, %rdi
callq 0xaf06
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::set_events(int&)
void Graph::set_events(int &P){
    numEvents = P;
    seedSets = new set<int>[P];
    seedSets_before = new set<int>[P];
    tsim_V_p.clear();
    tsim_V_p.resize(P, 0);
    for (int i = 1; i < getSize() + 1; i++){
        similarities[i].resize(P);
    }

    AP = new float*[P]; // Awareness probability of node from competitor
    for (int p = 0; p < P; p++)
        AP[p] = new float[getSize() + 1];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, 0x9d0(%rdi)
movslq (%rsi), %r15
movl $0x30, %ecx
movq %r15, %rax
mulq %rcx
seto %cl
orq $0x8, %rax
movq $-0x1, %r12
testb %cl, %cl
cmoveq %rax, %r12
movq %r12, %rdi
callq 0x3030
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testq %r15, %r15
je 0xe792
addq $0x10, %rax
movq %r15, %rdx
shlq $0x4, %rdx
leaq (%rdx,%rdx,2), %rdx
xorl %esi, %esi
movl $0x0, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rsi, 0x20(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0xe772
movq %rcx, 0xad0(%rbx)
movq %r12, %rdi
callq 0x3030
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testl %r15d, %r15d
je 0xe7de
addq $0x10, %rax
movq %r15, %rdx
shlq $0x4, %rdx
leaq (%rdx,%rdx,2), %rdx
xorl %esi, %esi
movl $0x0, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rsi, 0x20(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0xe7be
movq %rcx, 0xad8(%rbx)
leaq 0xb00(%rbx), %rdi
movq 0xb00(%rbx), %rax
cmpq %rax, 0xb08(%rbx)
je 0xe803
movq %rax, 0xb08(%rbx)
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rsi
callq 0x12958
movl 0x9c8(%rbx), %r12d
testl %r12d, %r12d
jle 0xe851
movl $0x18, %r15d
xorl %r13d, %r13d
movq 0xae0(%rbx), %rdi
addq %r15, %rdi
movslq (%r14), %rsi
callq 0x1298c
movslq 0x9c8(%rbx), %r12
incq %r13
addq $0x18, %r15
cmpq %r12, %r13
jl 0xe82c
movslq (%r14), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x3030
movq %rax, 0xb18(%rbx)
testq %r15, %r15
jle 0xe8ab
movslq %r12d, %rax
leaq 0x4(,%rax,4), %r14
cmpl $-0x1, %eax
cmovlq %r13, %r14
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x3030
movq 0xb18(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xe890
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::change_events(int&)
void Graph::change_events(int &P){
    delete [] seedSets;
    delete [] seedSets_before;
    for (int p = 0; p < numEvents; ++p){
        delete [] AP[p];
    }
    delete [] AP;
    set_events(P);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xad0(%rdi), %r12
testq %r12, %r12
je 0xe907
leaq -0x8(%r12), %r15
movq -0x8(%r12), %rax
testq %rax, %rax
je 0xe8ff
addq $-0x30, %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
leaq (%r12,%r13), %rdi
callq 0x12cfe
addq $-0x30, %r13
jne 0xe8f0
movq %r15, %rdi
callq 0x3410
movq 0xad8(%r14), %r12
testq %r12, %r12
je 0xe945
leaq -0x8(%r12), %r15
movq -0x8(%r12), %rax
testq %rax, %rax
je 0xe93d
addq $-0x30, %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
leaq (%r12,%r13), %rdi
callq 0x12cfe
addq $-0x30, %r13
jne 0xe92e
movq %r15, %rdi
callq 0x3410
cmpl $0x0, 0x9d0(%r14)
jle 0xe976
xorl %r15d, %r15d
movq 0xb18(%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0xe967
callq 0x3410
incq %r15
movslq 0x9d0(%r14), %rax
cmpq %rax, %r15
jl 0xe952
movq 0xb18(%r14), %rdi
testq %rdi, %rdi
je 0xe987
callq 0x3410
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe710
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_AP_IC(int, int, int, int)
float Graph::get_AP_IC(int u, int v, int idx, int p){
    float prob = probabilities[u][idx]; // (u) ---probabilities[u][idx]---> (v) (idx of (v) in adjacency list of (u))
    if (sim)
        prob *= similarities[v][p]; // similarity of the node (v) for the product p
    return prob;
}

// Assembly:
movslq %esi, %rax
movq 0x9f0(%rdi), %rsi
leaq (%rax,%rax,2), %rax
movslq %ecx, %rcx
movq (%rsi,%rax,8), %rax
movss (%rax,%rcx,4), %xmm0
cmpb $0x1, 0xb20(%rdi)
jne 0xea47
movslq %edx, %rax
movq 0xae0(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movslq %r8d, %rdx
movq (%rcx,%rax,8), %rax
cvtss2sd %xmm0, %xmm0
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_inv_AP_IC(int, int, int, int)
float Graph::get_inv_AP_IC(int u, int v, int idx, int p){
    float prob = weights[u][idx]; // (u) ---probabilities[u][idx]---> (v) (idx of (v) in adjacency list of (u))
    if (sim)
        prob *= similarities[u][p]; // similarity of the node (u) for the product p
    return prob;
}

// Assembly:
movslq %esi, %rax
movq 0xaa0(%rdi), %rdx
leaq (%rax,%rax,2), %rax
movslq %ecx, %rcx
movq (%rdx,%rax,8), %rdx
movss (%rdx,%rcx,4), %xmm0
cmpb $0x1, 0xb20(%rdi)
jne 0xea86
movq 0xae0(%rdi), %rcx
movslq %r8d, %rdx
movq (%rcx,%rax,8), %rax
cvtss2sd %xmm0, %xmm0
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::get_AP_LT(float, int, int)
float Graph::get_AP_LT(float active_prob, int u, int p){
    if (sim)
        return active_prob * similarities[u][p];
    else
        return active_prob;
}

// Assembly:
cmpb $0x1, 0xb20(%rdi)
jne 0xeab3
cvtss2sd %xmm0, %xmm0
movslq %esi, %rax
movq 0xae0(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
movq (%rcx,%rax,8), %rax
mulsd (%rax,%rdx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::create_AV_sets(Locations*, Locations*, int, Utilities)
void Graph::create_AV_sets(Locations* usersLocations, Locations* eventsLocations, int P, Utilities util){
    double max_dist = find_max_dist(P, usersLocations, eventsLocations, util);
    for (int v = 1; v <= getSize(); v++){
        A[v].clear();
        for (int p = 0; p < P; p++){
            similarities[v][p] = util.computeSimilarity(usersLocations->locations[v][0], usersLocations->locations[v][1], eventsLocations->locations[p][0], eventsLocations->locations[p][1], max_dist);
            A[v].insert(pair<double, int>(-similarities[v][p], p));
            tsim_V_p[p] += similarities[v][p];
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %r12
movl %ecx, 0x1c(%rsp)
movl %ecx, %esi
movq %rdx, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movq %rax, %rcx
callq 0xec3e
movsd %xmm0, 0x38(%rsp)
cmpl $0x0, 0x9c8(%r12)
jle 0xec2e
movl 0x1c(%rsp), %eax
movq %rax, 0x28(%rsp)
movl $0x1, %eax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %rbp
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0xaf8(%r12), %rdi
movq %rax, 0x40(%rsp)
addq %rax, %rdi
callq 0x13572
cmpl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
leaq 0xf(%rsp), %rbx
jle 0xec0f
movq 0x10(%rsp), %rax
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %r14
xorl %r15d, %r15d
movq (%rcx), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq (%r13), %rax
movq (%rax,%r15,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x38(%rsp), %xmm4
callq 0xcc50
movq 0xae0(%r12), %rax
movq (%rax,%r14), %rcx
movsd %xmm0, (%rcx,%r15,8)
movq 0xaf8(%r12), %rdi
addq 0x40(%rsp), %rdi
movq (%rax,%r14), %rax
movsd (%rax,%r15,8), %xmm0
xorps 0x9afc(%rip), %xmm0     # 0x186c0
movlps %xmm0, 0x48(%rsp)
movl %r15d, 0x50(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x135d6
movq 0xae0(%r12), %rax
movq 0xb00(%r12), %rcx
movq (%rax,%r14), %rax
movsd (%rax,%r15,8), %xmm0
addsd (%rcx,%r15,8), %xmm0
movsd %xmm0, (%rcx,%r15,8)
movq 0x20(%rsp), %rcx
incq %r15
cmpq %r15, %rbp
jne 0xeb60
movq 0x10(%rsp), %rdx
leaq 0x1(%rdx), %rax
movslq 0x9c8(%r12), %rcx
cmpq %rcx, %rdx
movq %rax, 0x10(%rsp)
jl 0xeb15
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::find_max_dist(int, Locations*, Locations*, Utilities)
double Graph::find_max_dist(int P,  Locations* usersLocations, Locations* eventsLocations, Utilities util){
    double max_dist = 0;
    double dist;
    for (int p = 0; p < P; ++p){
        for (int v = 1; v <= getSize(); ++v){
            dist = util.computeMinimumDistance(usersLocations->locations[v][0], usersLocations->locations[v][1], eventsLocations->locations[p][0], eventsLocations->locations[p][1], 'K');
            if (dist > max_dist){
                max_dist = dist;
            }
        }
    }
    return max_dist;
}

// Assembly:
testl %esi, %esi
jle 0xecec
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %eax
movq %rax, 0x8(%rsp)
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
leaq 0x7(%rsp), %r12
cmpl $0x0, 0x9c8(%r15)
jle 0xeccb
xorl %r13d, %r13d
movsd %xmm1, 0x10(%rsp)
movq (%r14), %rax
movq 0x8(%rax,%r13,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
movq %r12, %rdi
movl $0x4b, %esi
callq 0xcacc
maxsd 0x10(%rsp), %xmm0
movslq 0x9c8(%r15), %rax
incq %r13
movapd %xmm0, %xmm1
cmpq %rax, %r13
jl 0xec7c
jmp 0xeccf
movapd %xmm1, %xmm0
incq %rbp
movapd %xmm0, %xmm1
cmpq 0x8(%rsp), %rbp
jne 0xec6f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::rand_graph(float, float)
void Graph::rand_graph(float m, float s){
    default_random_engine generator;
    normal_distribution<float> distribution(m, s);
    float rand;
    int v;
    for (int i = 1; i <= numNodes; i++){
        probabilities[i].resize(node_deg[i]);
        for (int j = 0; j < node_deg[i]; j++){
            rand = distribution(generator);
            if (rand < 0)
                rand = 0;
            else if (rand > 1)
                rand = 1;
            probabilities[i][j] = rand;
            v = adjList[i][j];
            weights[v].push_back(rand);
        }
    }

    for (int i = 1; i <= numNodes; i++){
        weights[i].resize(inv_node_deg[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq $0x1, 0x20(%rsp)
movss %xmm0, 0x10(%rsp)
movss %xmm1, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movb $0x0, 0x1c(%rsp)
cmpl $0x0, 0x9c8(%rdi)
je 0xf078
movl $0x1, %r13d
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x3, %rdi
addq 0x9f0(%rbx), %rdi
movq 0xa20(%rbx), %rax
movslq (%rax,%r13,4), %rsi
callq 0x12824
movq 0xa20(%rbx), %rax
cmpl $0x0, (%rax,%r13,4)
jle 0xf062
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %rbp
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x136b2
movss %xmm0, 0xc(%rsp)
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xefdd
movl $0x0, 0xc(%rsp)
jmp 0xefee
ucomiss 0x90d8(%rip), %xmm0     # 0x180bc
jbe 0xefee
movl $0x3f800000, 0xc(%rsp)  # imm = 0x3F800000
movss 0xc(%rsp), %xmm0
movq 0x9f0(%rbx), %rax
movq (%rax,%rbp), %rax
movss %xmm0, (%rax,%r12,4)
movq 0x9d8(%rbx), %rax
movq 0xaa0(%rbx), %rcx
movq (%rax,%rbp), %rax
movslq (%rax,%r12,4), %rax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf041
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf04b
leaq 0xc(%rsp), %rdx
callq 0x138e6
incq %r12
movq 0xa20(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r12
jl 0xefb7
leaq 0x1(%r13), %rax
movl 0x9c8(%rbx), %ecx
cmpq %rcx, %r13
movq %rax, %r13
jb 0xef70
cmpl $0x0, 0x9c8(%rbx)
je 0xf0b7
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0xaa0(%rbx), %rdi
addq %r14, %rdi
movq 0xa70(%rbx), %rax
movslq 0x4(%rax,%r15,4), %rsi
callq 0x12824
movl 0x9c8(%rbx), %eax
incq %r15
addq $0x18, %r14
cmpq %rax, %r15
jb 0xf08a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::HyperGraph(unsigned int)
HyperGraph::HyperGraph(unsigned int n)
{
	sfmt_init_gen_rand(&sfmtSeed, rand());
	node_edge = vector<vector<int> >(n+1);
	maxDegree = 0;
	numNodes = n;
	curEdge=0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x40(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x30e0
movq %r15, %rdi
movl %eax, %esi
callq 0x16bbc
leal 0x1(%r14), %esi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x12ac2
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
movups (%rbx), %xmm0
movq 0x10(%rbx), %rax
leaq 0x10(%rsp), %r15
movaps (%r15), %xmm1
movups %xmm1, (%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r15)
movq %rcx, 0x10(%r15)
callq 0xaf12
movq %r15, %rdi
callq 0xaf12
movl %r14d, 0x38(%rbx)
movq %r12, 0x30(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xf173
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0xaf12
movq %rbx, %rdi
callq 0xaf12
movq %r14, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::updateDeg()
void HyperGraph::updateDeg(){
	unsigned int num=edge_node.size();
	for (unsigned int i = curEdge; i < num; ++i){
		unsigned int num2 = edge_node[i].size();
		for (unsigned int j=0;j<num2;++j){
			node_edge[edge_node[i][j]].push_back(i);
		}
	}
	curEdge = edge_node.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
subq 0x18(%rdi), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movl 0x30(%rdi), %r15d
cmpl %eax, %r15d
jae 0xf23b
movl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0xc(%rsp), %r14
movq 0x18(%rbx), %rcx
leaq (%r15,%r15,2), %r13
movq 0x8(%rcx,%r13,8), %rax
subq (%rcx,%r13,8), %rax
shrq $0x2, %rax
testl %eax, %eax
je 0xf231
movl %eax, %ebp
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rcx,%r12,4), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movl %r15d, 0xc(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf221
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf229
movq %r14, %rdx
callq 0xbc9c
incq %r12
cmpq %r12, %rbp
jne 0xf1ee
incq %r15
cmpq 0x10(%rsp), %r15
jne 0xf1d0
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::addEdge(std::vector<int, std::allocator<int>>&)
void HyperGraph::addEdge(vector<int> & edge)
{
	edge_node.push_back(edge);
	unsigned int ind = edge_node.size() - 1;
	for (unsigned int i = 0; i < edge.size(); ++i)
		node_edge[edge[i]].push_back(ind);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x12b4a
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0xf305
movq 0x20(%r14), %rcx
subq 0x18(%r14), %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ebp # imm = 0xAAAAAAAB
decl %ebp
movl $0x1, %r12d
xorl %ecx, %ecx
leaq 0xc(%rsp), %r15
movslq (%rax,%rcx,4), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movl %ebp, 0xc(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf2e4
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf2ec
movq %r15, %rdx
callq 0xbc9c
movl %r12d, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0xf2bb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::addEdgeD(std::vector<int, std::allocator<int>>&)
void HyperGraph::addEdgeD(vector<int> & edge)
{
    edge_node.push_back(edge);
    int ind = edge_node.size() - 1;
    for (unsigned int i = 0; i < edge.size(); ++i){
        node_edge[edge[i]].push_back(ind);
    	if (node_edge[edge[i]].size() > maxDegree)
    		maxDegree = node_edge[edge[i]].size();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x12b4a
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
movl %eax, 0xc(%rsp)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0xf3cc
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
movslq (%rax,%r12,4), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf384
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xf38c
movq %r15, %rdx
callq 0xd4bc
movq (%rbx), %rax
movslq (%rax,%r12,4), %rax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %rax
subq (%rcx,%rdx,8), %rax
sarq $0x2, %rax
movl 0x34(%r14), %ecx
cmpq %rcx, %rax
jbe 0xf3b4
movl %eax, 0x34(%r14)
movl %ebp, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
incl %ebp
cmpq %r12, %rcx
ja 0xf35b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: HyperGraph::clearEdges()
void HyperGraph::clearEdges()
{
    edge_node.clear();
    node_edge.clear();
    cout << "clear edges!" << endl;
    maxDegree = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x12b76
movq %rbx, %rdi
callq 0x12b76
movq 0xfb7f(%rip), %r14      # 0x1efd0
leaq 0x92d8(%rip), %rsi      # 0x18730
movl $0xc, %edx
movq %r14, %rdi
callq 0x33b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3360
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3240
movl $0x0, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/rwgraph.cpp
// Function: Graph::calculate_tsim(int)
double Graph::calculate_tsim(int P){
    float** aware_all_ev = new float*[P];
    for (int p = 0; p < P; ++p){
        aware_all_ev[p] = new float[getSize() + 1];
        for(int v = 0; v <= getSize(); v++){
            aware_all_ev[p][v] = 0;
        }
    }
    
    for (int ev = 0; ev < P; ev++){
        if (model == 0){
            rand_LT();
            BFS_LT(ev, aware_all_ev);
        }
        else{
            BFS_IC(ev, aware_all_ev);
        }
    }

    double total_sim = 0;
    double max_weight;
    for (int v = 1; v <= getSize(); ++v){
        max_weight = 0;
        for (int p = 0; p < P; ++p){
            if (aware_all_ev[p][v] != 0 && similarities[v][p] > max_weight){
                max_weight = similarities[v][p];
            }
        }
        total_sim += max_weight;
    }

    for (int p = 0; p < P; ++p){
        delete [] aware_all_ev[p];
    }
    delete [] aware_all_ev;

    return total_sim;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
leaq (,%r15,8), %rdi
testl %r15d, %r15d
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x3030
movq %rax, %rbx
movl %ebp, 0x14(%rsp)
movl %ebp, %r13d
testl %r15d, %r15d
jle 0x111e3
movslq 0x9c8(%r14), %rbp
cmpq $-0x1, %rbp
leaq 0x4(,%rbp,4), %r15
cmovlq %r12, %r15
leal 0x1(%rbp), %eax
shlq $0x2, %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x3030
movq %rax, (%rbx,%r12,8)
testl %ebp, %ebp
js 0x111db
movq %rax, %rdi
xorl %esi, %esi
movq 0x8(%rsp), %rdx
callq 0x31c0
incq %r12
cmpq %r12, %r13
jne 0x111bc
movl 0x14(%rsp), %ebp
testl %ebp, %ebp
jle 0x11226
xorl %r15d, %r15d
cmpl $0x0, 0xa60(%r14)
je 0x11208
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x10858
jmp 0x1121e
movq %r14, %rdi
callq 0x107d0
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x10c22
incl %r15d
cmpl %r15d, %ebp
jne 0x111ee
movl 0x9c8(%r14), %eax
testl %eax, %eax
jle 0x11293
movq 0xae0(%r14), %rcx
incq %rax
xorpd %xmm3, %xmm3
movl $0x1, %edx
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
testl %ebp, %ebp
jle 0x11285
leaq (%rdx,%rdx,2), %rsi
leaq (%rcx,%rsi,8), %rsi
xorl %edi, %edi
movq (%rbx,%rdi,8), %r8
movss (%r8,%rdx,4), %xmm2
ucomiss %xmm0, %xmm2
jne 0x1126a
jnp 0x1127d
movq (%rsi), %r8
movsd (%r8,%rdi,8), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1127d
movapd %xmm2, %xmm1
incq %rdi
cmpq %rdi, %r13
jne 0x11259
addsd %xmm1, %xmm3
incq %rdx
cmpq %rax, %rdx
jne 0x11247
jmp 0x11297
xorpd %xmm3, %xmm3
movsd %xmm3, 0x8(%rsp)
testl %ebp, %ebp
jle 0x112ba
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x112b2
callq 0x3410
incq %r14
cmpq %r14, %r13
jne 0x112a4
movq %rbx, %rdi
callq 0x3410
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/option.cpp
// Function: OptionParser::OptionParser(int, char**)
OptionParser::OptionParser(int argc, char ** argv){
	for (int i = 1; i < argc; i += 2){
		if (argv[i][0] == '-'){
			if (i + 1 <= argc){
				std::string tmp(argv[i]);
				paras.insert(std::make_pair(tmp, argv[i + 1]));
			}else{
				isValid = false;
				return;
			}
		} else {
			isValid = false;
			return;
		}
	}
	isValid = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
cmpl $0x2, %esi
setge %al
jl 0x148a0
movq %rdx, %r14
movl %esi, %ebp
movq 0x8(%rdx), %rsi
cmpb $0x2d, (%rsi)
jne 0x14898
leaq 0x30(%rsp), %r13
movl $0x3, %r15d
leaq 0x20(%rsp), %r12
movq %rsp, %rdi
movq %r12, %rdx
callq 0x3140
movq %r13, 0x20(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xb2e6
movq -0x8(%r14,%r15,8), %rax
movq %rax, 0x40(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x16098
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x14870
callq 0x3340
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14883
callq 0x3340
cmpl %ebp, %r15d
setl %al
jge 0x148a0
movq (%r14,%r15,8), %rsi
addq $0x2, %r15
cmpb $0x2d, (%rsi)
je 0x14828
movb $0x0, 0x30(%rbx)
testb %al, %al
jne 0x148a4
movb $0x1, 0x30(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x148ca
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x148ca
callq 0x3340
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x148e2
callq 0x3340
jmp 0x148e2
movq %rax, %r14
movq %rbx, %rdi
callq 0xb28a
movq %r14, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/dtsaras[P]GCW/option.cpp
// Function: OptionParser::getPara(char const*)
char * OptionParser::getPara(const char * str){
	std::string tmp(str);
	std::map<std::string, char *>::iterator it = paras.find(tmp);
	if (it == paras.end())
		return NULL;
	else
		return it->second;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16276
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x14928
movq 0x40(%rax), %rbx
jmp 0x1492a
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1493d
callq 0x3340
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1495e
callq 0x3340
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH09_SequentialContainers/examples/find-str.cc
// Function: main
int main()
{
    string name("AnnaBelle");
    auto pos1 = name.find("Anna"); // pos1 == 0
    cout << pos1 ;
    string lowercase("annabelle");
    pos1 = lowercase.find("Anna");   // pos1 == npos
    cout << " " << pos1 << endl;
    cout << string::npos << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xdac(%rip), %rsi       # 0x2004
leaq 0xdae(%rip), %rdx       # 0x200d
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x13ca
leaq 0xd9c(%rip), %rsi       # 0x200e
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10d0
movq 0x2d50(%rip), %rdi      # 0x3fd8
movq %rax, %rsi
callq 0x1040
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xd74(%rip), %rsi       # 0x2013
leaq 0xd76(%rip), %rdx       # 0x201c
leaq -0x38(%rbp), %rdi
callq 0x13ca
leaq 0xd58(%rip), %rsi       # 0x200e
leaq -0x38(%rbp), %rdi
movl $0x4, %ecx
xorl %edx, %edx
callq 0x10d0
movq %rax, %rbx
movq 0x2d08(%rip), %rdi      # 0x3fd8
leaq 0xd46(%rip), %rsi       # 0x201d
movl $0x1, %edx
callq 0x10b0
movq 0x2cf0(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x1040
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq 0x2cb7(%rip), %rdi      # 0x3fd8
movq $-0x1, %rsi
callq 0x1040
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x136c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x1381
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1390
movq %rax, %rbx
jmp 0x13ad
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x13ad
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x13c2
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/pixel.hpp
// Function: operator<<(std::ostream&, pixel3 const&)
std::ostream& operator << (std::ostream& out, const pixel3& p){
    out << "("
        << std::setw(3) << std::to_string(p.r) << ", "
        << std::setw(3) << std::to_string(p.g) << ", "
        << std::setw(3) << std::to_string(p.b) << ")";
    
    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4f99(%rip), %rsi      # 0x7536
movl $0x1, %edx
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rbx,%rax)
movzbl 0x2(%r14), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r15d
cmovael %eax, %r15d
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x2d, %edx
callq 0x2260
movq (%r12), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x5de0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %r15
leaq 0x4a0d(%rip), %rsi      # 0x7028
movl $0x2, %edx
movq %rax, %rdi
callq 0x2250
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl 0x1(%r14), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r12d
cmovael %eax, %r12d
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
movl $0x2d, %edx
callq 0x2260
movq 0x28(%rsp), %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x5de0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x2250
movq %rax, %r15
leaq 0x498d(%rip), %rsi      # 0x7028
movl $0x2, %edx
movq %rax, %rdi
callq 0x2250
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r15,%rax)
movzbl (%r14), %ebp
cmpl $0x64, %ebp
movl $0x3, %eax
sbbl $0x0, %eax
cmpl $0xa, %ebp
movl $0x1, %r14d
cmovael %eax, %r14d
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x2d, %edx
callq 0x2260
movq 0x8(%rsp), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x5de0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2250
leaq 0x4913(%rip), %rsi      # 0x702b
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x273c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2220
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2753
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2220
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x276f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27a1
jmp 0x27bd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x27a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2220
jmp 0x27a4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x27c0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2220
jmp 0x27c0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x27dc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: print_help(char const*)
void print_help(const char* progname){
    std::cout << "Usage:" << std::endl;
    std::cout << progname << " <option> [ <extra1> <extra2> ... ]" << std::endl;
    std::cout << R"(
Options must be provided in the given order.
Options are mutually exclusive.
Possible options:

    --psf <img1> <img2> <psf_file>          :  calculate psfs for two images and store in <out>
                                               * img1 and img2 - images to calculate shift between
                                               * psf_file - output file with psf profile
    
    --scale <img> <psf_file> <out_img>      :  scale image according to its
                                               corresponding psf profile in psf_file and cuts
                                               a strip of given width from their center
    
    --merge <out_img> <img_1> ... <img_N>   :  merge images from left to right in given order
                                               and saves the result with name <out_img>
    
    --help                                  :  display this help text
    )" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x74af(%rip), %rbx      # 0x9fc8
leaq 0x450d(%rip), %rsi      # 0x702d
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
testq %r14, %r14
je 0x2b75
movq %r14, %rdi
callq 0x20e0
movq 0x7460(%rip), %rdi      # 0x9fc8
movq %r14, %rsi
movq %rax, %rdx
callq 0x2250
jmp 0x2b8c
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2350
leaq 0x44a1(%rip), %rsi      # 0x7034
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
leaq 0x448a(%rip), %rsi      # 0x7058
movl $0x38e, %edx            # imm = 0x38E
movq %rbx, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: psf_resize(BMP_image, std::vector<float, std::allocator<float>>, unsigned int)
BMP_image psf_resize(const BMP_image img, std::vector<float> psf, unsigned int th){
    // max psf
    float max_psf = 0;
    for(auto& p : psf) if(p > max_psf) max_psf = p;

    unsigned int width = img.info_h.width;
    unsigned int height = img.info_h.height;
    int new_w = width * max_psf;
    
    BMP_image res(new_w, height);

    // resize each strip and write centered
    for(int i=0; i<psf.size(); ++i){
        x_enlarge_region(img, {0, i*th}, {width-1, std::min((i+1)*th, height)}, res, {(int) floor((new_w - floor(width*psf[i]))/2), i*th}, psf[i]);
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x38(%rsp)
movq %rdx, %r15
movq %rsi, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
cmpq %rcx, %rax
je 0x3cad
xorps %xmm0, %xmm0
movss (%rax), %xmm1
maxss %xmm0, %xmm1
addq $0x4, %rax
movaps %xmm1, %xmm0
cmpq %rcx, %rax
jne 0x3c97
jmp 0x3cb0
xorps %xmm1, %xmm1
movq 0x18(%rsp), %rax
movl 0x12(%rax), %ebx
xorps %xmm0, %xmm0
cvtsi2ss %rbx, %xmm0
movl 0x16(%rax), %ebp
movss %xmm0, 0x14(%rsp)
mulss %xmm0, %xmm1
movaps %xmm1, 0x20(%rsp)
cvttss2si %xmm1, %esi
movq 0x8(%rsp), %rdi
movl %ebp, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
callq 0x577a
cvttps2dq 0x20(%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
leal -0x1(%rbx), %eax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
xorl %eax, %eax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x3da6
movq 0x38(%rsp), %rdx
leal (%rdx,%r13), %r12d
cmpl %r12d, %ebp
movl %r12d, %r14d
cmovbl %ebp, %r14d
leaq 0x1(%rax), %rbx
movss (%rcx,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp)
mulss 0x14(%rsp), %xmm0
callq 0x20c0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movapd 0x40(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x32ba(%rip), %xmm0     # 0x7020
callq 0x2340
cvttsd2si %xmm0, %r8d
shlq $0x20, %r13
shlq $0x20, %r14
addq 0x30(%rsp), %r14
orq %r13, %r8
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
movss 0x20(%rsp), %xmm0
callq 0x3776
movl %r12d, %r13d
movq %rbx, %rax
jmp 0x3d09
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x5926
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/iibrahimli[P]adsa_project/src/../include/util.hpp
// Function: cut_strip(BMP_image const&, unsigned int)
BMP_image cut_strip(const BMP_image& img, unsigned int strip_width){
    unsigned int width = img.info_h.width;
    unsigned int height = img.info_h.height;
    unsigned int strip_start = (unsigned int) floor((float) (width - strip_width)/2);

    BMP_image res(strip_width, height);

    for(int j=0; j<height; ++j){
        for(int i=0; i<strip_width; ++i){
            res(i, j) = img.ploc(i+strip_start, j);
        }
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl 0x12(%rsi), %eax
subl %edx, %eax
cvtsi2ss %rax, %xmm0
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movl 0x16(%rsi), %r12d
mulss 0x3213(%rip), %xmm0     # 0x7010
callq 0x20c0
movss %xmm0, 0x8(%rsp)
movq %r14, %rbx
movq %r14, %rdi
movl %ebp, %r15d
movl %ebp, %esi
movl %r12d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
callq 0x577a
movl %r12d, 0xc(%rsp)
testl %r12d, %r12d
je 0x3e7b
cvttss2si 0x8(%rsp), %r14
xorl %r12d, %r12d
testl %r15d, %r15d
je 0x3e71
xorl %r13d, %r13d
leal (%r14,%r13), %esi
movq 0x10(%rsp), %rdi
movl %r12d, %edx
callq 0x4f20
movq %rax, %rbp
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x53f2
movl (%rbp), %ecx
movl %ecx, (%rax)
incl %r13d
cmpl %r13d, %r15d
jne 0x3e42
incl %r12d
cmpl 0xc(%rsp), %r12d
jne 0x3e3a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5926
movq %r14, %rdi
callq 0x23a0