LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::get_centroids_map()
std::vector<std::vector<int>> get_centroids_map() {
			// we want to keep a map containing the true values of the vectors, in order to find the median
			std::vector<std::vector<int>> centroids_map(k);
			// insert the vectors in the map
			for (int i = 0; i < n_points; i++) {
				int assigned = assigned_centroid.at(i);
				centroids_map.at(assigned).push_back(i);
			}	
			return centroids_map;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0xa65e
movl $0x0, (%rsp)
cmpl $0x0, 0x4(%r14)
jle 0x4dca
xorl %eax, %eax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq %rsp, %r15
movslq %eax, %rsi
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x4dd9
movslq (%rcx,%rsi,4), %rsi
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x4dd9
leaq (%rsi,%rsi,2), %rdx
leaq (%rcx,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4db4
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4dbc
movq %r15, %rdx
callq 0xa702
movl (%rsp), %eax
incl %eax
movl %eax, (%rsp)
cmpl 0x4(%r14), %eax
jl 0x4d64
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6545(%rip), %rdi      # 0xb325
xorl %eax, %eax
callq 0x2370
jmp 0x4de9
movq %rax, %r14
movq %rbx, %rdi
callq 0x55fc
movq %r14, %rdi
callq 0x2450
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::~Clustering()
~Clustering(){
			// free the pointers to the classes in case we have a reverse assignment method selected
			if (assignment_method == "reverse_LSH") 
				delete lsh_instant;
			if (assignment_method == "reverse_Hypercube") 
				delete hc_instant;

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x5d2e(%rip), %rsi      # 0xb283
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x5590
movq 0x80(%rbx), %r15
testq %r15, %r15
je 0x5588
leaq 0x50(%r15), %rdi
callq 0x3656
leaq 0x38(%r15), %rdi
callq 0x6166
leaq 0x20(%r15), %rdi
callq 0x7022
movq %r15, %rdi
callq 0x2260
leaq 0x5d0f(%rip), %rsi      # 0xb2a6
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
jne 0x55bf
movq 0x98(%rbx), %r14
testq %r14, %r14
je 0x55b7
movq %r14, %rdi
callq 0xa9c6
movq %r14, %rdi
callq 0x2260
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x55cd
callq 0x2260
leaq 0x48(%rbx), %rdi
callq 0x3656
leaq 0x30(%rbx), %rdi
callq 0x3656
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x55f6
popq %rbx
popq %r14
popq %r15
jmp 0x2260
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::assignment_lloyds()
int assignment_lloyds(void) {
			// keep track of the changes in assignments
			int changes = 0;
			// itterate each vector of the dataset
			for (int i = 0; i < n_points; i++) {
				int prev = assigned_centroid.at(i);
				assigned_centroid.at(i) = nearest_centroid(feature_vectors.at(i));
				// check and record changed centroids
				if (prev != assigned_centroid.at(i))
					changes++;
			}

			return changes;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0x4(%rdi)
jle 0x8a0c
movq %rdi, %r14
movq 0x60(%rdi), %r8
movq 0x68(%rdi), %rdx
xorl %r12d, %r12d
movq %rsp, %r15
xorl %ebx, %ebx
xorl %ebp, %ebp
subq %r8, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x8a1f
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x8a1f
movl (%r8,%rbx,4), %r13d
addq %r12, %rsi
movq %r15, %rdi
callq 0x393a
movq %r14, %rdi
movq %r15, %rsi
callq 0x96c4
movq 0x60(%r14), %r8
movq 0x68(%r14), %rdx
movq %rdx, %rcx
subq %r8, %rcx
sarq $0x2, %rcx
cmpq %rbx, %rcx
jbe 0x8a3f
movl %eax, (%r8,%rbx,4)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x89e6
callq 0x2260
movq 0x60(%r14), %r8
movq 0x68(%r14), %rdx
movq %rdx, %rcx
subq %r8, %rcx
sarq $0x2, %rcx
cmpq %rbx, %rcx
jbe 0x8a2b
xorl %eax, %eax
cmpl (%r8,%rbx,4), %r13d
setne %al
addl %eax, %ebp
incq %rbx
movslq 0x4(%r14), %rax
addq $0x18, %r12
cmpq %rax, %rbx
jl 0x895b
jmp 0x8a0e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28ff(%rip), %rdi      # 0xb325
movq %rbx, %rsi
jmp 0x8a38
leaq 0x28f3(%rip), %rdi      # 0xb325
movq %rbx, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2370
leaq 0x28df(%rip), %rdi      # 0xb325
movq %rbx, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2370
jmp 0x8a55
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8a66
callq 0x2260
movq %rbx, %rdi
callq 0x2450
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::nearest_centroid(std::vector<double, std::allocator<double>>)
int nearest_centroid(vector<T> vec) {
			T min_dist = (T)INT_MAX;
			int nearest = -1;
			// compute the distances to all the centroids
			for (int i = 0; i < k; i++) {
				T dist = metrics::ManhatanDistance(vec, centroids.at(i), space_dim);
				// set it as min
				if (dist < min_dist) {
					min_dist = dist;
					nearest = i;
				}
			}
			assert(nearest != -1);

			return nearest;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, (%rdi)
jle 0x97fe
movq %rsi, %rbx
movq %rdi, %r15
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movsd 0x1af2(%rip), %xmm0     # 0xb1e0
xorl %r14d, %r14d
leaq 0x18(%rsp), %r12
leaq 0x30(%rsp), %r13
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x393a
movq 0x30(%r15), %rax
movq 0x38(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r14, %rdx
jbe 0x97ed
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r13, %rdi
callq 0x393a
movslq 0x8(%r15), %rax
movq 0x30(%rsp), %rdi
testq %rax, %rax
movapd 0x1a9a(%rip), %xmm1     # 0xb1f0
xorpd %xmm2, %xmm2
jle 0x977f
movq 0x18(%rsp), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
subsd (%rdi,%rdx,8), %xmm0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rdx
cmpq %rdx, %rax
jne 0x9763
jmp 0x9784
testq %rdi, %rdi
je 0x9795
movsd %xmm2, 0x8(%rsp)
callq 0x2260
movsd 0x8(%rsp), %xmm2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
movsd 0x10(%rsp), %xmm0
je 0x97bc
movsd %xmm2, 0x8(%rsp)
callq 0x2260
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
cmovbl %r14d, %ebp
minsd %xmm2, %xmm0
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0x96fb
cmpl $-0x1, %ebp
je 0x97fe
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b31(%rip), %rdi      # 0xb325
movq %r14, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0x1f82(%rip), %rdi      # 0xb787
leaq 0x1bb8(%rip), %rsi      # 0xb3c4
leaq 0x1f2c(%rip), %rcx      # 0xb73f
movl $0x40, %edx
callq 0x21a0
jmp 0x981f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9831
callq 0x2260
movq %rbx, %rdi
callq 0x2450
nop
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::min_dist_between_centroids()
T min_dist_between_centroids() {
			// initialize the min distance
			T min_dist = (T)INT_MAX;
			// brute force all the distances in order to find the smallest
			for (int i = 0; i < k; i++) {
				for (int j = 0; j < k; j++) {
					if (i != j) {
						T dist = metrics::ManhatanDistance(centroids.at(i), centroids.at(j), space_dim);
						if (dist < min_dist)
							min_dist = dist;
					}
				}
			} 

			return min_dist;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl (%rdi), %eax
testl %eax, %eax
jle 0x9984
movq %rdi, %r14
movsd 0x1983(%rip), %xmm0     # 0xb1e0
xorl %ebx, %ebx
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x30(%rsp), %r12
testl %eax, %eax
jle 0x9973
leaq (%rbx,%rbx,2), %r15
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x9964
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
cmpq %rbx, %rdx
jbe 0x999b
movsd %xmm0, 0x10(%rsp)
leaq (%rax,%r15,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0x393a
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbp, %rdx
cmpq %r13, %rdx
jbe 0x99ac
leaq (,%r13,2), %rcx
addq %r13, %rcx
leaq (%rax,%rcx,8), %rsi
movq %r12, %rdi
callq 0x393a
movslq 0x8(%r14), %rax
movq 0x30(%rsp), %rdi
xorpd %xmm2, %xmm2
testq %rax, %rax
jle 0x9926
movq 0x18(%rsp), %rcx
xorl %edx, %edx
movapd 0x18e6(%rip), %xmm1     # 0xb1f0
movsd (%rcx,%rdx,8), %xmm0
subsd (%rdi,%rdx,8), %xmm0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rdx
cmpq %rdx, %rax
jne 0x990a
jmp 0x992b
testq %rdi, %rdi
je 0x993c
movsd %xmm2, 0x8(%rsp)
callq 0x2260
movsd 0x8(%rsp), %xmm2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9957
movsd %xmm2, 0x8(%rsp)
callq 0x2260
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
minsd %xmm2, %xmm0
movl (%r14), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x987d
incq %rbx
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0x986e
jmp 0x998c
movsd 0x1854(%rip), %xmm0     # 0xb1e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1983(%rip), %rdi      # 0xb325
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0x1972(%rip), %rdi      # 0xb325
movq %r13, %rsi
xorl %eax, %eax
callq 0x2370
jmp 0x99bf
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x99d1
callq 0x2260
movq %rbx, %rdi
callq 0x2450
nop
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::count_unassigned(std::vector<int, std::allocator<int>>)
int count_unassigned(vector<int> assigned) {
			int res = 0;
			for (int i = 0; i < n_points; i++) {
				if (assigned.at(i) == UNASSIGNED) {
					res++;
				}
			}
			
			return res;
		}

// Assembly:
pushq %rax
movslq 0x4(%rdi), %rcx
testq %rcx, %rcx
jle 0xa22c
movq (%rsi), %rdi
movq 0x8(%rsi), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
leal -0x1(%rcx), %eax
cmpq %rax, %rdx
jbe 0xa230
xorl %edx, %edx
xorl %eax, %eax
xorl %esi, %esi
cmpl $-0x1, (%rdi,%rdx,4)
sete %sil
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0xa216
jmp 0xa22e
xorl %eax, %eax
popq %rcx
retq
leaq 0x10ee(%rip), %rdi      # 0xb325
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O3/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Clustering/../../algorithms/Clustering/clustering.h
// Function: Clustering<double>::second_nearest_centroid(std::vector<double, std::allocator<double>>)
int second_nearest_centroid(vector <T> vec) {
			// get the nearest centroid
			int nearest = nearest_centroid(vec);

			T min_dist = (T)INT_MAX;
			int second_nearest = -1;
			// compute the distances to all the centroids
			for (int i = 0; i < k; i++) {
				T dist = metrics::ManhatanDistance(vec, centroids.at(i), space_dim);
				// set it as min
				if (dist < min_dist && i != nearest) {
					min_dist = dist;
					second_nearest = i;
				}
			}
			assert(second_nearest != -1);

			return second_nearest;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x393a
movq %r14, %rdi
movq %r15, %rsi
callq 0x96c4
movl %eax, %ebp
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xa857
callq 0x2260
cmpl $0x0, (%r14)
jle 0xa981
movl %ebp, %r12d
movsd 0x974(%rip), %xmm0      # 0xb1e0
movsd %xmm0, 0x8(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
leaq 0x40(%rsp), %r13
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x393a
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0xa970
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r13, %rdi
callq 0x393a
movslq 0x8(%r14), %rax
movq 0x40(%rsp), %rdi
testq %rax, %rax
movapd 0x91a(%rip), %xmm1      # 0xb1f0
xorpd %xmm2, %xmm2
jle 0xa8ff
movq 0x10(%rsp), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
subsd (%rdi,%rdx,8), %xmm0
andpd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rdx
cmpq %rdx, %rax
jne 0xa8e3
jmp 0xa904
testq %rdi, %rdi
je 0xa913
movsd %xmm2, (%rsp)
callq 0x2260
movsd (%rsp), %xmm2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa92c
movsd %xmm2, (%rsp)
callq 0x2260
movsd (%rsp), %xmm2
ucomisd 0x8(%rsp), %xmm2
setae %al
cmpq %r12, %r15
sete %cl
orb %al, %cl
testb %cl, %cl
jne 0xa947
movsd %xmm2, 0x8(%rsp)
cmovel %r15d, %ebp
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0xa87f
cmpl $-0x1, %ebp
je 0xa981
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ae(%rip), %rdi       # 0xb325
movq %r15, %rsi
xorl %eax, %eax
callq 0x2370
leaq 0xdf8(%rip), %rdi       # 0xb780
leaq 0xa35(%rip), %rsi       # 0xb3c4
leaq 0xdff(%rip), %rcx       # 0xb795
movl $0x55, %edx
callq 0x21a0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0xa9b4
jmp 0xa9ac
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa9be
callq 0x2260
movq %rbx, %rdi
callq 0x2450
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/perf_built_co_sst.cpp
// Function: main
int main(){
    srand(10);
    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
    int n, Q;
    cin >> n >> Q;
    test(n, Q);
    chrono::steady_clock::time_point end = chrono::steady_clock::now();
    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xa, %edi
callq 0x10f0
callq 0x1160
movq %rax, %rbx
movq 0x2527(%rip), %rdi      # 0x4fe0
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x10a0
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x10a0
movl (%r14), %edi
movl (%r15), %esi
callq 0x28b8
callq 0x1160
movq %rax, %r14
movq 0x24e0(%rip), %r15      # 0x4fd0
leaq 0x6a2(%rip), %rsi       # 0x3199
movl $0x12, %edx
movq %r15, %rdi
callq 0x1140
subq %rbx, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x10e0
movq %rax, %rbx
leaq 0x675(%rip), %rsi       # 0x31ac
movl $0x5, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/test/SafeQueue.hpp
// Function: BSignals::details::SafeQueue<BigThing>::enqueue(BigThing const&)
void enqueue(const T &t){
        std::unique_lock<std::mutex> lock(m);
        q.push(t);
        lock.unlock();
        c.notify_one();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x258(%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0xd76c
movb $0x1, 0x8(%r15)
movq 0x238(%rbx), %rdi
movq $-0x200, %rax           # imm = 0xFE00
addq 0x248(%rbx), %rax
cmpq %rax, %rdi
je 0x11cca
movl $0x200, %edx            # imm = 0x200
movq %r14, %rsi
callq 0xb430
addq $0x200, 0x238(%rbx) # imm = 0x200
jmp 0x11cd9
leaq 0x208(%rbx), %rdi
movq %r14, %rsi
callq 0x15302
movq %rsp, %rdi
callq 0xd7a8
addq $0x280, %rbx            # imm = 0x280
movq %rbx, %rdi
callq 0xb280
movq %rsp, %rdi
callq 0xd756
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd756
movq %rbx, %rdi
callq 0xba10
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/test/SafeQueue.hpp
// Function: BSignals::details::SafeQueue<BigThing>::dequeue()
T dequeue(void){
        std::unique_lock<std::mutex> lock(m);
        if (terminateFlag) return shutdownObject;
        while (q.empty()){
            c.wait(lock);
            if (terminateFlag) return shutdownObject;
        }
        T val = q.front();
        q.pop();
        return val;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x258(%rsi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0xd76c
movb $0x1, 0x8(%r15)
cmpb $0x0, 0x200(%r14)
jne 0x1206f
leaq 0x280(%r14), %r15
leaq 0x8(%rsp), %r12
movq 0x218(%r14), %rsi
cmpq %rsi, 0x238(%r14)
jne 0x12081
movq %r15, %rdi
movq %r12, %rsi
callq 0xb150
cmpb $0x1, 0x200(%r14)
jne 0x1204a
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb430
jmp 0x1209d
addq $0x208, %r14            # imm = 0x208
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0x1a95e
leaq 0x8(%rsp), %rdi
callq 0xd756
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: int BSignals::details::SignalImpl<unsigned int>::connectMemberSlot<void (TestClass::*)(unsigned int), TestClass*>(BSignals::ExecutorScheme, void (TestClass::*&&)(unsigned int), TestClass*&&)
int connectMemberSlot(BSignals::ExecutorScheme scheme, F&& function, C&& instance){
        //type check assertions
        static_assert(std::is_member_function_pointer<F>::value, "function is not a member function");
        static_assert(std::is_object<std::remove_reference<C>>::value, "instance is not a class object");
        
        //Construct a bound function from the function pointer and object
        auto boundFunc = objectBind(function, instance);
        return connectSlot(scheme, boundFunc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq (%rcx), %r13
leaq 0x20(%rsp), %r12
movq $0x0, 0x8(%r12)
movl $0x18, %edi
callq 0xb4e0
movq %r13, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r12)
leaq 0x25a(%rip), %rax       # 0x12a98
movq %rax, 0x18(%r12)
leaq 0x26c(%rip), %rax       # 0x12ab6
movq %rax, 0x10(%r12)
movq %rsp, %rdi
movq %r12, %rsi
callq 0x12a3a
movq %rsp, %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x128f8
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12880
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x12899
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x128ef
jmp 0x128ef
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x128ce
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x128ce
jmp 0x128ef
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x128e7
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xba10
movq %rax, %rdi
callq 0xd7cf
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<unsigned int>::connectSlot(BSignals::ExecutorScheme, std::function<void (unsigned int)>)
int connectSlot(BSignals::ExecutorScheme scheme, std::function<void(Args...)> slot){
        uint32_t id = currentId.fetch_add(1);
        if (enableEmissionGuard){
            std::lock_guard<std::mutex> lock(connectBufferLock);
            connectBuffer.emplace(id, ConnectDescriptor{scheme, slot});
            connectBufferDirty = true;
            return id;
        }
        else{
            return connectSlotFunction(id, scheme, slot);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r12
movq %rdi, %r14
movl $0x1, %ebx
lock
xaddl %ebx, (%rdi)
movl %esi, %ebp
movl %ebx, 0x4(%rsp)
cmpb $0x1, 0x4(%rdi)
jne 0x1298e
leaq 0xb8(%r14), %rbx
movq %rbx, %rdi
callq 0xb830
testl %eax, %eax
jne 0x129d7
leaq 0x30(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x12a3a
leaq 0xe8(%r14), %rdi
leaq 0x4(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x12e08
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x12977
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movb $0x1, %al
xchgb %al, 0xe0(%r14)
movl 0x4(%rsp), %ebp
movq %rbx, %rdi
callq 0xb3f0
jmp 0x129c8
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x12a3a
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r15, %rcx
callq 0x12b42
movl %eax, %ebp
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x129c8
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0xb370
jmp 0x12a31
jmp 0x12a31
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x12a03
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x12a03
jmp 0x12a31
movq %rax, %r14
movq %rbx, %rdi
callq 0xb3f0
jmp 0x12a29
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12a29
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xba10
movq %rax, %rdi
callq 0xd7cf
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/StrandSlot.hpp
// Function: BSignals::details::StrandSlot<unsigned int>::queueListener()
void queueListener(){
        std::tuple<Args...> tuple{};
        auto maxWait = WheeledThreadPool::getMaxWait();
        std::chrono::duration<double> waitTime = std::chrono::nanoseconds(1);
        while (!stop){
            if (strandQueue.dequeue(tuple)){
                if (!stop) this->callFuncWithTuple(tuple, std::index_sequence_for<Args...>());
                waitTime = std::chrono::nanoseconds(1);
            }
            else{
                std::this_thread::sleep_for(waitTime);
                waitTime*=2;
            }
            if (waitTime > maxWait){
                strandQueue.blockingDequeue(tuple);
                if (!stop) this->callFuncWithTuple(tuple, std::index_sequence_for<Args...>());
                waitTime = std::chrono::nanoseconds(1);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
callq 0xdd3e
movsd %xmm0, 0x28(%rsp)
cmpb $0x0, 0x238(%rbx)
jne 0x13757
leaq 0x30(%rbx), %r14
leaq 0x8(%rbx), %r15
movsd 0x359d0(%rip), %xmm1    # 0x49020
leaq 0xc(%rsp), %r12
leaq 0x18(%rsp), %r13
movsd %xmm1, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x13908
testb %al, %al
je 0x136aa
cmpb $0x0, 0x238(%rbx)
movsd 0x359a2(%rip), %xmm1    # 0x49020
jne 0x13706
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x13765
movq %r15, %rdi
movq %r13, %rsi
callq *0x20(%rbx)
movsd 0x35978(%rip), %xmm1    # 0x49020
jmp 0x13706
movsd 0x10(%rsp), %xmm1
ucomisd 0x35970(%rip), %xmm1    # 0x49028
jbe 0x13702
cvttsd2si %xmm1, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm1
mulsd 0x35935(%rip), %xmm1    # 0x49008
cvttsd2si %xmm1, %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %r13, %rdi
movq %r13, %rsi
callq 0xb160
cmpl $-0x1, %eax
jne 0x136fc
callq 0xb070
cmpl $0x4, (%rax)
je 0x136e2
movsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
ucomisd 0x28(%rsp), %xmm1
jbe 0x1374a
movq %r14, %rdi
movq %r12, %rsi
callq 0x13980
cmpb $0x0, 0x238(%rbx)
movsd 0x358f8(%rip), %xmm1    # 0x49020
jne 0x1374a
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x13765
movq %r15, %rdi
movq %r13, %rsi
callq *0x20(%rbx)
movsd 0x358d6(%rip), %xmm1    # 0x49020
cmpb $0x1, 0x238(%rbx)
jne 0x1365a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xb1f0
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ThreadPooledSlot.hpp
// Function: BSignals::details::ThreadPooledSlot<unsigned int>::execute(unsigned int const&)
void execute(const Args& ... args){
        WheeledThreadPool::run([this, args...](){
            if (!checkIfValid || checkIfValid()){
                this->slotFunction(args...);
            }
        });
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl (%rsi), %eax
movq %rsp, %rbx
movq $0x0, 0x8(%rbx)
movq %rdi, (%rbx)
movl %eax, 0x8(%rbx)
leaq 0x3b(%rip), %rax        # 0x13dfc
movq %rax, 0x18(%rbx)
leaq 0x36(%rip), %rax        # 0x13e02
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0xd9f0
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x13dee
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0xd7cf
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/AsynchronousSlot.hpp
// Function: BSignals::details::AsynchronousSlot<BigThing>::execute(BigThing const&)
void execute(const Args& ... args){
        sem.acquire();
        std::thread slotThread([this, args...](){
            if (!checkIfValid || checkIfValid()){
                this->slotFunction(args...);
            }
            sem.release();
        });
        slotThread.detach();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %rdi
callq 0xd6ca
leaq 0x18(%rsp), %rdi
movq %r14, -0x8(%rdi)
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rsi
callq 0xb430
leaq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x19e88
movq %rbx, %rdi
callq 0xb9f0
cmpq $0x0, 0x8(%rsp)
jne 0x19e82
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
cmpq $0x0, 0x8(%rsp)
jne 0x19e82
movq %rax, %rdi
callq 0xba10
callq 0xb130
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ContiguousMPMCQueue.hpp
// Function: BSignals::details::ContiguousMPMCQueue<std::pair<std::function<void ()>, unsigned int>, 16ul>::dequeue(std::pair<std::function<void ()>, unsigned int>&)
bool dequeue(T& data){
        size_t       tail_seq = _tail_seq.load(std::memory_order_relaxed);
        while(true){
            node_t*  node     = &_buffer[tail_seq & (N-1)];
            size_t   node_seq = node->seq.load(std::memory_order_acquire);
            intptr_t dif      = (intptr_t) node_seq - (intptr_t)(tail_seq + 1);
            if (dif == 0) {
                if (_tail_seq.compare_exchange_weak(tail_seq, tail_seq + 1, std::memory_order_relaxed)) {
                    data = node->data;
                    node->seq.store(tail_seq + N, std::memory_order_release);
                    return true;
                }
            }
            else if (dif < 0){
                return false;
            }
            else{
                tail_seq = _tail_seq.load(std::memory_order_relaxed);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x388(%rdi), %r15
movl %r15d, %eax
andl $0xf, %eax
leaq (%rax,%rax,2), %rcx
shll $0x4, %ecx
movq 0x28(%rbx,%rcx), %r12
leaq 0x1(%r15), %r13
cmpq %r13, %r12
jne 0x1450c
movq %r15, %rax
lock
cmpxchgq %r12, 0x388(%rbx)
je 0x14517
movq %rax, %r15
jmp 0x144de
jl 0x14534
movq 0x388(%rbx), %r15
jmp 0x144de
addq %rcx, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe558
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r14)
addq $0x10, %r15
movq %r15, 0x28(%rbx)
cmpq %r13, %r12
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ContiguousMPMCQueue.hpp
// Function: BSignals::details::ContiguousMPMCQueue<std::pair<std::function<void ()>, unsigned int>, 16ul>::enqueue(std::pair<std::function<void ()>, unsigned int> const&)
bool enqueue(const T& data){
        size_t  head_seq = _head_seq.load(std::memory_order_relaxed);
        while(true){
            node_t*  node     = &_buffer[head_seq & (N-1)];
            size_t   node_seq = node->seq.load(std::memory_order_acquire);
            intptr_t dif      = (intptr_t) node_seq - (intptr_t) head_seq;

            if (dif == 0){
                if (_head_seq.compare_exchange_weak(head_seq, head_seq + 1, std::memory_order_relaxed)) {
                    node->data = data;
                    node->seq.store(head_seq + 1, std::memory_order_release);
                    return true;
                }
            }
            else if (dif < 0){
                return false;
            }
            else{
                head_seq = _head_seq.load(std::memory_order_relaxed);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x340(%rdi), %r15
movl %r15d, %eax
andl $0xf, %eax
leaq (%rax,%rax,2), %rcx
shll $0x4, %ecx
movq 0x28(%rbx,%rcx), %r12
cmpq %r15, %r12
jne 0x148ac
leaq 0x1(%r15), %r13
movq %r15, %rax
lock
cmpxchgq %r13, 0x340(%rbx)
je 0x148b7
movq %rax, %r15
jmp 0x1487e
jl 0x148d0
movq 0x340(%rbx), %r15
jmp 0x1487e
addq %rcx, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe558
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq %r13, 0x28(%rbx)
cmpq %r15, %r12
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<int, int>::disconnectSlot(int)
void disconnectSlot(int id){
        if (enableEmissionGuard){
            slotLock.lock_shared();
            auto it = slots.find(id);
            if (it == slots.end()) return;
            it->second->markForDeath();
            slotLock.unlock_shared();
        }
        else{
            disconnectSlotFunction(id);
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
cmpb $0x1, 0x4(%rdi)
jne 0x17bd5
movq %rbx, %rdi
callq 0xd84e
movq 0x98(%r14), %rcx
testq %rcx, %rcx
je 0x17c1a
addq $0x90, %r14
movq %r14, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x17ba1
cmpq %r14, %rax
je 0x17c1a
cmpl %ebp, 0x20(%rax)
ja 0x17c1a
movq 0x28(%rax), %rax
movb $0x0, 0x28(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd87c
movq %rbx, %rdi
callq 0xd7dc
movq 0x98(%r14), %rax
testq %rax, %rax
je 0x17c1a
leaq 0x88(%r14), %rdi
addq $0x90, %r14
movq %r14, %rsi
xorl %ecx, %ecx
cmpl %ebp, 0x20(%rax)
setb %cl
cmovaeq %rax, %rsi
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0x17bfa
cmpq %r14, %rsi
je 0x17c1a
cmpl %ebp, 0x20(%rsi)
jbe 0x17c1f
popq %rbx
popq %r14
popq %rbp
retq
callq 0x17828
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd83c
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<int, int>::invokeDeferred()
void invokeDeferred(){
        slotLock.lock_shared();
        std::pair<std::function<void()>, uint32_t> deferredInvocation;
        if (!deferredQueue) return;
        while (deferredQueue->dequeue(deferredInvocation)){
            if (!enableEmissionGuard || getIsStillConnectedFromExecutor(deferredInvocation.second)){
                deferredInvocation.first();
            }
        }
        slotLock.unlock_shared();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0xd84e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x0, 0x20(%rsp)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x18248
leaq 0x90(%r14), %r12
movq %rsp, %r15
movq %r15, %rsi
callq 0x14448
testb %al, %al
je 0x18229
cmpb $0x1, 0x4(%r14)
jne 0x1820a
movl 0x20(%rsp), %ebp
movq %rbx, %rdi
callq 0xd84e
movq 0x98(%r14), %rcx
testq %rcx, %rcx
je 0x181fa
movq %r12, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x181da
cmpq %r12, %rax
je 0x181fa
cmpl %ebp, 0x20(%rax)
jbe 0x1821f
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xd87c
testb $0x1, %bpl
je 0x18219
cmpq $0x0, 0x10(%rsp)
je 0x18255
movq %r15, %rdi
callq *0x18(%rsp)
movq 0x8(%r14), %rdi
jmp 0x181ac
movq 0x28(%rax), %rax
movb 0x28(%rax), %bpl
jmp 0x181fc
movq %rbx, %rdi
callq 0xd87c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x18248
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb1f0
jmp 0x18280
jmp 0x1825e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x18278
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xba10
movq %rax, %rdi
callq 0xd7cf
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/gtest.h
// Function: testing::WithParamInterface<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>>::GetParam() const
const ParamType& GetParam() const {
    GTEST_CHECK_(parameter_ != NULL)
        << "GetParam() can only be called inside a value-parameterized test "
        << "-- did you intend to write TEST_P instead of TEST_F?";
    return *parameter_;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x9e21c(%rip), %rbx     # 0xbda10
xorl %edi, %edi
cmpq $0x0, (%rbx)
setne %dil
callq 0x2703b
testb %al, %al
jne 0x1f874
leaq 0x2ba9e(%rip), %rdx     # 0x4b2ac
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x6dc, %ecx            # imm = 0x6DC
callq 0x45a8a
movq 0x4b7bf(%rip), %rdi     # 0x6afe8
leaq 0x2baa2(%rip), %rsi     # 0x4b2d2
movl $0x25, %edx
callq 0xb600
movq 0x4b7a7(%rip), %rdi     # 0x6afe8
leaq 0x2bab0(%rip), %rsi     # 0x4b2f8
movl $0x40, %edx
callq 0xb600
movq 0x4b78f(%rip), %rdi     # 0x6afe8
leaq 0x2bad9(%rip), %rsi     # 0x4b339
movl $0x34, %edx
callq 0xb600
leaq 0xc(%rsp), %rdi
callq 0x45bcc
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x45bcc
movq %rbx, %rdi
callq 0xba10
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::CartesianProductHolder6<testing::internal::ValueArray1<int>, testing::internal::ValueArray1<int>, testing::internal::ValueArray1<int>, testing::internal::ValueArray7<int, int, int, int, int, int, int>, testing::internal::ValueArray2<bool, bool>, testing::internal::ValueArray3<BSignals::ExecutorScheme, BSignals::ExecutorScheme, BSignals::ExecutorScheme>>::operator testing::internal::ParamGenerator<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>><unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>() const
operator ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >() const {
    return ParamGenerator< ::testing::tuple<T1, T2, T3, T4, T5, T6> >(
        new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
        static_cast<ParamGenerator<T1> >(g1_),
        static_cast<ParamGenerator<T2> >(g2_),
        static_cast<ParamGenerator<T3> >(g3_),
        static_cast<ParamGenerator<T4> >(g4_),
        static_cast<ParamGenerator<T5> >(g5_),
        static_cast<ParamGenerator<T6> >(g6_)));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x68, %edi
callq 0xb4e0
movq %rax, %rbx
movl (%r15), %eax
leaq 0x34(%rsp), %rdx
movl %eax, -0x4(%rdx)
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x24979
movl 0x4(%r15), %eax
leaq 0x24(%rsp), %rdx
movl %eax, -0x4(%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x24979
movl 0x8(%r15), %eax
leaq 0x14(%rsp), %rdx
movl %eax, -0x4(%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x24979
leaq 0xc(%r15), %rsi
leaq 0x10(%rsp), %rdi
callq 0x24868
movb 0x28(%r15), %al
leaq 0x42(%rsp), %rdx
movb %al, -0x2(%rdx)
movb 0x29(%r15), %al
movb %al, -0x1(%rdx)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x24e31
movq 0x2c(%r15), %rax
leaq 0x7c(%rsp), %rdx
movq %rax, -0xc(%rdx)
movl 0x34(%r15), %eax
movl %eax, -0x4(%rdx)
leaq 0x40(%rsp), %r15
leaq 0x70(%rsp), %rsi
movq %r15, %rdi
callq 0x253d9
movq %r15, (%rsp)
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x50(%rsp), %r9
movq %rbx, %rdi
callq 0x2489c
movq %rbx, (%r14)
leaq 0x8(%r14), %rax
movq %rax, 0x8(%r14)
leaq 0x40(%rsp), %rdi
callq 0x26b24
leaq 0x50(%rsp), %rdi
callq 0x26b4e
leaq 0x10(%rsp), %rdi
callq 0x26b78
leaq 0x20(%rsp), %rdi
callq 0x26b78
leaq 0x30(%rsp), %rdi
callq 0x26b78
leaq 0x60(%rsp), %rdi
callq 0x26b78
movq %r14, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x26b24
jmp 0x20643
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x26b4e
jmp 0x20652
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x26b78
jmp 0x20661
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x26b78
jmp 0x20670
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x26b78
leaq 0x60(%rsp), %rdi
callq 0x26b78
movl $0x68, %esi
movq %rbx, %rdi
callq 0xb510
movq %r14, %rdi
callq 0xba10
movq %rax, %r14
jmp 0x2067a
movq %rax, %r14
jmp 0x20684
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: testing::internal::linked_ptr_internal::join(testing::internal::linked_ptr_internal const*)
GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
    MutexLock lock(&g_linked_ptr_mutex);

    linked_ptr_internal const* p = ptr;
    while (p->next_ != ptr) {
      assert(p->next_ != this &&
             "Trying to join() a linked ring we are already in. "
             "Is GMock thread safety enabled?");
      p = p->next_;
    }
    p->next_ = this;
    next_ = ptr;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9d0b3(%rip), %rdi     # 0xbdaf0
callq 0x20a96
movq %rbx, %rax
movq (%rax), %rcx
cmpq %rbx, %rcx
je 0x20a74
movq %rcx, %rax
cmpq %r14, %rcx
jne 0x20a45
leaq 0x2a65c(%rip), %rdi     # 0x4b0b8
leaq 0x2a535(%rip), %rsi     # 0x4af98
leaq 0x2a6b9(%rip), %rcx     # 0x4b123
movl $0x74, %edx
callq 0xb360
movq %r14, (%rax)
movq %rbx, (%r14)
leaq 0x9d06f(%rip), %rdi     # 0xbdaf0
callq 0x20b34
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xd7cf
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: testing::internal::linked_ptr_internal::depart()
bool depart()
      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
    MutexLock lock(&g_linked_ptr_mutex);

    if (next_ == this) return true;
    linked_ptr_internal const* p = next_;
    while (p->next_ != this) {
      assert(p->next_ != next_ &&
             "Trying to depart() a linked ring we are not in. "
             "Is GMock thread safety enabled?");
      p = p->next_;
    }
    p->next_ = next_;
    return false;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9cdaa(%rip), %rdi     # 0xbdaf0
callq 0x20a96
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x20d88
movq %r14, %rax
movq (%rax), %rcx
cmpq %rbx, %rcx
je 0x20d85
movq %rcx, %rax
cmpq %r14, %rcx
jne 0x20d56
leaq 0x2a486(%rip), %rdi     # 0x4b1f3
leaq 0x2a224(%rip), %rsi     # 0x4af98
leaq 0x2a4e2(%rip), %rcx     # 0x4b25d
movl $0x86, %edx
callq 0xb360
movq %r14, (%rax)
leaq 0x9cd61(%rip), %rdi     # 0xbdaf0
callq 0x20b34
cmpq %rbx, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xd7cf
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/gtest-printers.h
// Function: void testing::internal::TuplePrefixPrinter<5ul>::PrintPrefixTo<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>>(std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme> const&, std::ostream*)
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
    GTEST_INTENTIONAL_CONST_COND_PUSH_()
    if (N > 1) {
    GTEST_INTENTIONAL_CONST_COND_POP_()
      *os << ", ";
    }
    UniversalPrinter<
        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x22140
leaq 0x2c404(%rip), %rsi     # 0x4e50a
movl $0x2, %edx
movq %rbx, %rdi
callq 0xb600
movzbl 0x4(%r14), %edx
leaq 0x28d7a(%rip), %rax     # 0x4ae99
leaq 0x28d6d(%rip), %rsi     # 0x4ae93
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb600
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/test/FunctionTimeRegular.hpp
// Function: FunctionTimeRegular<>::threadLoop()
void threadLoop(){
        auto begin = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed = std::chrono::high_resolution_clock::now() - begin;
        std::unique_lock<std::mutex> lock(m_mutex);
        for (std::chrono::duration<double> lastTime=elapsed; m_keepGoing; lastTime += m_interval){
            if (!m_tfunc())
                break;
            elapsed = std::chrono::high_resolution_clock::now() - begin;
            m_cv.wait_for(lock, m_interval - (elapsed-lastTime));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xb090
movq %rax, %r14
callq 0xb090
movq %rax, %r15
leaq 0x8(%rbx), %rax
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0xd76c
movb $0x1, 0x8(%r12)
movb (%rbx), %al
testb $0x1, %al
je 0x243bd
subq %r14, %r15
cvtsi2sd %r15, %xmm0
divsd 0x24ccc(%rip), %xmm0    # 0x49008
movsd %xmm0, 0x8(%rsp)
leaq 0x70(%rbx), %r15
leaq 0x30(%rbx), %r12
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
cmpq $0x0, 0x80(%rbx)
je 0x243d6
movq %r15, %rdi
callq *0x88(%rbx)
testb %al, %al
je 0x243bd
callq 0xb090
subq %r14, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x24c85(%rip), %xmm0    # 0x49008
subsd 0x8(%rsp), %xmm0
movsd 0x68(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2447c
movsd 0x8(%rsp), %xmm0
addsd 0x68(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movb (%rbx), %al
testb $0x1, %al
jne 0x24354
leaq 0x18(%rsp), %rdi
callq 0xd756
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb1f0
jmp 0x243df
jmp 0x243df
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd756
movq %rbx, %rdi
callq 0xba10
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::ValueArray7<int, int, int, int, int, int, int>::operator testing::internal::ParamGenerator<unsigned int><unsigned int>() const
operator ParamGenerator<T>() const {
    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
        static_cast<T>(v6_), static_cast<T>(v7_)};
    return ValuesIn(array);
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
leaq 0x1c(%rsp), %rdx
movaps %xmm0, -0x1c(%rdx)
movq 0x10(%rsi), %rax
movq %rax, -0xc(%rdx)
movl 0x18(%rsi), %eax
movl %eax, -0x4(%rdx)
movq %rsp, %rsi
callq 0x24979
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util.h
// Function: testing::internal::ValuesInIteratorRangeGenerator<unsigned int>::Iterator::Equals(testing::internal::ParamIteratorInterface<unsigned int> const&) const
virtual bool Equals(const ParamIteratorInterface<T>& other) const {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      return iterator_ ==
          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
xorl %edi, %edi
cmpq %rax, %r15
sete %dil
callq 0x2703b
testb %al, %al
jne 0x24d06
leaq 0x26730(%rip), %rdx     # 0x4b3a2
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x155, %ecx            # imm = 0x155
callq 0x45a8a
movq 0x4635b(%rip), %rdi     # 0x6afe8
leaq 0x26889(%rip), %rsi     # 0x4b51d
movl $0x3b, %edx
callq 0xb600
movq 0x46343(%rip), %rdi     # 0x6afe8
leaq 0x268ad(%rip), %rsi     # 0x4b559
movl $0x2b, %edx
callq 0xb600
movq 0x4632b(%rip), %r15     # 0x6afe8
leaq 0x268c1(%rip), %rsi     # 0x4b585
movl $0x1a, %edx
movq %r15, %rdi
callq 0xb600
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0xb4c0
movsbl %al, %esi
movq 0x462f9(%rip), %rdi     # 0x6afe8
callq 0xb050
movq %rax, %rdi
callq 0xb390
leaq 0xc(%rsp), %rdi
callq 0x45bcc
movq %r14, %rdi
callq 0x24d6d
movq 0x10(%rbx), %rcx
cmpq 0x10(%rax), %rcx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x45bcc
movq %rbx, %rdi
callq 0xba10