LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: isaacbrodsky[P]K-means-plus-plus/k-means-multi.cpp
// Function: Cluster_set::Cluster_set()
Cluster_set::Cluster_set(void){

	// local variables
	random_device rd;

	// initialize the class variables
	iIteration = 0;
	iK_count = 1;
	sIn_file = "default_in.dat";
	sOut_file = "default_out.txt";
	bUseLabels = false;
	fTolerance = 0.1f;
	// Use K-means++ by default.
	bUsePlusPlus = true;
	// Seed with real random value if available
	mtRandom = mt19937(rd());
	iNumThreads = 1;
	iNumPlusPlusThreads = 1;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2760, %rsp           # imm = 0x2760
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2730(%rbp)
movq %rdi, %rax
movq %rax, -0x2758(%rbp)
callq 0xa0c0
movq -0x2730(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x2750(%rbp)
callq 0xa0c0
movq -0x2730(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x2748(%rbp)
callq 0x4440
movq -0x2730(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x2740(%rbp)
callq 0x4440
movq -0x2730(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x2738(%rbp)
callq 0xa0e0
movq -0x2730(%rbp), %rdi
addq $0xa8, %rdi
callq 0xa100
jmp 0x54aa
leaq -0x13a0(%rbp), %rdi
callq 0xa120
jmp 0x54b8
movq -0x2758(%rbp), %rdi
movl $0x0, 0x98(%rdi)
movl $0x1, 0x30(%rdi)
addq $0x38, %rdi
leaq 0x1103d(%rip), %rsi     # 0x16518
callq 0x4430
jmp 0x54e2
movq -0x2758(%rbp), %rdi
addq $0x58, %rdi
leaq 0x11033(%rip), %rsi     # 0x16527
callq 0x4430
jmp 0x54fb
movq -0x2758(%rbp), %rax
movb $0x0, 0xa0(%rax)
movl $0x3dcccccd, 0x78(%rax) # imm = 0x3DCCCCCD
movb $0x1, 0xa1(%rax)
leaq -0x13a0(%rbp), %rdi
callq 0xa1c0
movl %eax, -0x275c(%rbp)
jmp 0x552b
movl -0x275c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2728(%rbp), %rdi
callq 0xa1e0
jmp 0x5543
movq -0x2758(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x2728(%rbp), %rsi
movl $0x1388, %edx           # imm = 0x1388
callq 0x4290
movq -0x2758(%rbp), %rax
movl $0x1, 0x1434(%rax)
movl $0x1, 0x1430(%rax)
leaq -0x13a0(%rbp), %rdi
callq 0xa210
addq $0x2760, %rsp           # imm = 0x2760
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x55b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x13a0(%rbp), %rdi
callq 0xa210
movq -0x2738(%rbp), %rdi
callq 0x4a30
movq -0x2740(%rbp), %rdi
callq 0x4200
movq -0x2748(%rbp), %rdi
callq 0x4200
movq -0x2750(%rbp), %rdi
callq 0x4a90
movq -0x2730(%rbp), %rdi
callq 0x4a90
movq -0x10(%rbp), %rdi
callq 0x4530
nopl (%rax)
// File: isaacbrodsky[P]K-means-plus-plus/k-means-multi.cpp
// Function: Cluster_set::Execute_clustering()
void Cluster_set::Execute_clustering(void){

	// local variables
	bool bNot_done = true;

	// read the input data
	if (Read_input_data()) {

		// loop until we are done clustering - the mean values don't change
		while (bNot_done){

			// identify the k means values
			Identify_mean_values();

			// cluster the input data using the k means values
			Cluster_data();

			// calculate the means of the clusters
			Calculate_cluster_means();

			// compare the old mean values to the new mean values
			// if the difference is less than the tolerance value then stop clustering
			bNot_done = Compare_mean_values();

			// increment the iteration
			iIteration++;

			// end the main loop
		} // while

		// write the output data
		Write_output_data();
	} // If input data read

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
callq 0x5b20
testb $0x1, %al
jne 0x5ac3
jmp 0x5b15
jmp 0x5ac5
testb $0x1, -0x9(%rbp)
je 0x5b0c
movq -0x18(%rbp), %rdi
callq 0x5ea0
movq -0x18(%rbp), %rdi
callq 0x6060
movq -0x18(%rbp), %rdi
callq 0x61e0
movq -0x18(%rbp), %rdi
callq 0x63f0
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x9(%rbp)
movl 0x98(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x98(%rax)
jmp 0x5ac5
movq -0x18(%rbp), %rdi
callq 0x6500
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: isaacbrodsky[P]K-means-plus-plus/k-means-multi.cpp
// Function: Cluster_set::Cluster_data()
void Cluster_set::Cluster_data(void){
	if (iNumThreads == 1)
	{
		//Don't bother creating more threads.
		Cluster_data_process(0, vclInput_data.size());
	}
	else
	{
		// local variables
		unsigned uPerThread;
		unsigned uData;
		unsigned uDataStart;
		int iThread_index;
		vector<thread> vtThreads;

		uDataStart = 0;
		uData = vclInput_data.size();
		uPerThread = uData / iNumThreads;

		//Split the dataset into parts and launch as individual
		//threads.
		for (iThread_index = 0; iThread_index < iNumThreads; iThread_index++)
		{
			//Force the last thread to take remaining data
			if (iThread_index == iNumThreads - 1)
			{
				uPerThread = uData - uDataStart;
			}

			vtThreads.push_back(thread([=](unsigned uStart, unsigned uLength) { Cluster_data_process(uStart, uLength); }, uDataStart, uPerThread));

			uDataStart += uPerThread;
		} // Launch all threads

		//Wait for all threads to complete.
		for (iThread_index = 0; iThread_index < iNumThreads; iThread_index++)
		{
			vtThreads[iThread_index].join();
		} // Wait for all threads
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x1, 0x1434(%rax)
jne 0x609f
movq -0x58(%rbp), %rdi
addq $0x80, %rdi
callq 0xa5b0
movq -0x58(%rbp), %rdi
movl %eax, %edx
xorl %esi, %esi
callq 0x7270
jmp 0x61cb
leaq -0x30(%rbp), %rdi
callq 0xaac0
movq -0x58(%rbp), %rdi
movl $0x0, -0x14(%rbp)
addq $0x80, %rdi
callq 0xa5b0
movq -0x58(%rbp), %rcx
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
xorl %edx, %edx
divl 0x1434(%rcx)
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1434(%rcx), %eax
jge 0x617b
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
movl 0x1434(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x610b
movl -0x10(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x73d0
jmp 0x612a
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaae0
jmp 0x6139
leaq -0x38(%rbp), %rdi
callq 0xab10
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x60db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x61c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xab10
jmp 0x61c0
movl $0x0, -0x18(%rbp)
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1434(%rcx), %eax
jge 0x61b5
movslq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xab40
movq %rax, %rdi
callq 0x45a8
jmp 0x61a8
jmp 0x61aa
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6182
leaq -0x30(%rbp), %rdi
callq 0xab60
jmp 0x61cb
leaq -0x30(%rbp), %rdi
callq 0xab60
jmp 0x61d1
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4530
nopw (%rax,%rax)
// File: isaacbrodsky[P]K-means-plus-plus/k-means-multi.cpp
// Function: Cluster_set::Compare_mean_values()
bool Cluster_set::Compare_mean_values(void){

	// local variables
	bool bNot_done;
	float sStep_difference;
	float fResult_difference = 0;
	int iCluster_index, iAttribute_index;

	// calculate the difference between the old means and the new means
	for (iCluster_index = 0; iCluster_index < iK_count; iCluster_index++){ // by each cluster
		// compare the attribute mean values
		for (iAttribute_index = 0; iAttribute_index < iAttribute_ct; iAttribute_index++){

			sStep_difference = vvfMeans[iCluster_index][iAttribute_index]
				- vvfOld_means[iCluster_index][iAttribute_index];
			// guarantee a positive value without using squares
			if (sStep_difference < 0) sStep_difference = sStep_difference * (-1);

			// add the step difference to the total difference of means
			fResult_difference = fResult_difference + sStep_difference;

		} // for

	} // for

	// stop clustering if there is little change in  the mean values
	if (fResult_difference < fTolerance) bNot_done = false;
	else bNot_done = true;

	return bNot_done;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x64d2
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x9c(%rcx), %eax
jge 0x64c2
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xa4e0
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa3c0
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0xa4e0
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa3c0
movss -0x2c(%rbp), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x64a5
movss 0xfbe5(%rip), %xmm0     # 0x16080
mulss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x14(%rbp), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x642a
jmp 0x64c4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6413
movq -0x28(%rbp), %rax
movss -0x14(%rbp), %xmm1
movss 0x78(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x64eb
movb $0x0, -0x9(%rbp)
jmp 0x64ef
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: akw0088[P]openssl/rsa_dec.cpp
// Function: createRSA(unsigned char*, bool)
RSA *createRSA(unsigned char *key, bool pub)
{
	RSA *rsa = NULL;
	BIO *keybio = BIO_new_mem_buf(key, -1); // a bio is just a memory buffer, -1 means do strlen of char *key

	if (keybio == NULL)
	{
		printf( "Failed to create key BIO");
		return 0;
	}

	if (pub)
	{
		rsa = PEM_read_bio_RSA_PUBKEY(keybio, &rsa, NULL, NULL);
	}
	else
	{
		rsa = PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);
	}
	BIO_free_all(keybio);

	if (rsa == NULL)
	{
		printf( "Failed to create RSA");
	}
 
	return rsa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12bd
leaq 0xd58(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movq $0x0, -0x8(%rbp)
jmp 0x131b
testb $0x1, -0x11(%rbp)
je 0x12dd
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1160
movq %rax, -0x20(%rbp)
jmp 0x12f5
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1140
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1080
cmpq $0x0, -0x20(%rbp)
jne 0x1313
leaq 0xd11(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: akw0088[P]openssl/rsa_dec.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned char *prikey = NULL;
	unsigned int size;

	if (argc < 3)
	{
		printf("Usage: dec private_key encrypted_file\r\n");
		return -1;
	}

	prikey = (unsigned char *)get_file(argv[1], &size);
	if (prikey == NULL)
	{
		printf("Failed to open private key\r\n");
		return -1;
	}

	unsigned int encrypted_length = 0;

	unsigned char *encrypted = (unsigned char *)get_file(argv[2], &encrypted_length);

	printf("Read %d bytes of encrypted file\r\n", encrypted_length);
	unsigned char decrypted[4098]={};

	
	RSA *rsa = createRSA(prikey, false);
	int decrypted_length = RSA_private_decrypt(encrypted_length, encrypted, decrypted, rsa, RSA_PKCS1_PADDING);
	if (decrypted_length == -1)
	{
		char err[130];

		ERR_load_crypto_strings();
		ERR_error_string(ERR_get_error(), err);
		printf("ERROR: %s\n", err);
		return -1;
	}
	RSA_free(rsa);

	printf("Decrypted Text: %s\n", decrypted);
	printf("Decrypted Length: %d\n", decrypted_length);
	write_file((char *)"file.txt", (char *)decrypted, decrypted_length);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10c0, %rsp           # imm = 0x10C0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x1511
leaq 0xb77(%rip), %rdi       # 0x2075
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x165d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1547
leaq 0xb69(%rip), %rdi       # 0x209d
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x165d
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1330
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %esi
leaq 0xb4d(%rip), %rdi       # 0x20ba
movb $0x0, %al
callq 0x1050
leaq -0x1030(%rbp), %rdi
xorl %esi, %esi
movl $0x1002, %edx           # imm = 0x1002
callq 0x10a0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1270
movq %rax, -0x1038(%rbp)
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
leaq -0x1030(%rbp), %rdx
movq -0x1038(%rbp), %rcx
movl $0x1, %r8d
callq 0x10b0
movl %eax, -0x103c(%rbp)
cmpl $-0x1, -0x103c(%rbp)
jne 0x1608
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
callq 0x1120
movq %rax, %rdi
leaq -0x10c0(%rbp), %rsi
callq 0x1070
leaq -0x10c0(%rbp), %rsi
leaq 0xae4(%rip), %rdi       # 0x20dc
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x165d
movq -0x1038(%rbp), %rdi
callq 0x10f0
leaq -0x1030(%rbp), %rsi
leaq 0xac5(%rip), %rdi       # 0x20e7
movb $0x0, %al
callq 0x1050
movl -0x103c(%rbp), %esi
leaq 0xac5(%rip), %rdi       # 0x20fb
movb $0x0, %al
callq 0x1050
leaq -0x1030(%rbp), %rsi
movl -0x103c(%rbp), %edx
leaq 0xac0(%rip), %rdi       # 0x2111
callq 0x1430
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10c0, %rsp           # imm = 0x10C0
popq %rbp
retq
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: operator-(HourMin const&, HourMin const&)
unsigned operator-(const HourMin& hmLater, const HourMin& hmSooner)
{
   HourMin hmLater2 = hmLater;
   if (hmLater2 < hmSooner)
      hmLater2.h += 24;
   unsigned r = (hmLater2.h - hmSooner.h) * 60;
   if (hmLater2.m >= hmSooner.m)
      r += hmLater2.m - hmSooner.m;
   else
      r -= hmSooner.m - hmLater2.m;
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x7010
testb $0x1, %al
jne 0x366e
jmp 0x3677
movl -0x18(%rbp), %eax
addl $0x18, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
imull $0x3c, %eax, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x36a4
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x4(%rcx), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x36b6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl -0x14(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: isEmptyOrWhitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isEmptyOrWhitespace(const std::string& s)
{
   for (size_t i = 0; i < s.size(); ++i)
      if (!isspace(s[i]))
         return false;
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3831
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32e0
movsbl (%rax), %edi
callq 0x3070
cmpl $0x0, %eax
jne 0x3821
movb $0x0, -0x1(%rbp)
jmp 0x3835
jmp 0x3823
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x37e4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: lowerCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string lowerCase(const std::string& s)
{
   std::string r = s;
   for (size_t i = 0; i < r.size(); ++i)
      if ((r[i] >= 'A') && (r[i] <= 'Z'))
         r[i] = (char)(r[i] - 'A' + 'a');
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3120
movq $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x31d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x3935
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x50(%rbp)
jmp 0x38a4
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x3922
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x58(%rbp)
jmp 0x38c3
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x3922
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x60(%rbp)
jmp 0x38e2
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rax
movb (%rax), %al
addb $0x20, %al
movb %al, -0x69(%rbp)
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x68(%rbp)
jmp 0x3900
movq -0x68(%rbp), %rax
movb -0x69(%rbp), %cl
movb %cl, (%rax)
jmp 0x3922
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3190
jmp 0x3952
jmp 0x3924
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3870
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3948
movq -0x40(%rbp), %rdi
callq 0x3190
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: upperCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string upperCase(const std::string& s)
{
    std::string r = s;
    for (size_t i = 0; i < r.size(); ++i)
        if ((r[i] >= 'a') && (r[i] <= 'z'))
            r[i] = (char)(r[i] - 'a' + 'A');
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3120
movq $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x31d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x3a55
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x50(%rbp)
jmp 0x39c4
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x3a42
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x58(%rbp)
jmp 0x39e3
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x3a42
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x60(%rbp)
jmp 0x3a02
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rax
movb (%rax), %al
addb $-0x20, %al
movb %al, -0x69(%rbp)
movq -0x20(%rbp), %rsi
callq 0x34f0
movq %rax, -0x68(%rbp)
jmp 0x3a20
movq -0x68(%rbp), %rax
movb -0x69(%rbp), %cl
movb %cl, (%rax)
jmp 0x3a42
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3190
jmp 0x3a72
jmp 0x3a44
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3990
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3a68
movq -0x40(%rbp), %rdi
callq 0x3190
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: expandStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
std::string expandStr(const std::string& str, size_t size)
{
   size_t strLen = str.length();
   if (strLen >= size)
      return str;
   else
      return str + std::string(size - strLen, ' ');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x3acb
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3120
jmp 0x3b5c
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3490
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movl $0x20, %edx
callq 0x31b0
jmp 0x3b07
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x7070
jmp 0x3b1a
leaq -0x40(%rbp), %rdi
callq 0x3190
leaq -0x41(%rbp), %rdi
callq 0x32c0
jmp 0x3b5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3b51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
leaq -0x41(%rbp), %rdi
callq 0x32c0
jmp 0x3b69
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: hoursMinsStr[abi:cxx11](unsigned int, unsigned long)
std::string hoursMinsStr(unsigned minutes, size_t size = 0)
{
   std::ostringstream oss;
   oss.precision(2);
   oss << std::fixed << minutes / 60.0 << " h";

   return expandStr(oss.str(), size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x3390
movq -0x190(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x190(%rbp,%rax), %rdi
movl $0x2, %esi
callq 0x70c0
jmp 0x3bd2
leaq 0x3517(%rip), %rsi      # 0x70f0
leaq -0x190(%rbp), %rdi
callq 0x30d0
movq %rax, -0x1d8(%rbp)
jmp 0x3bee
movq -0x1d8(%rbp), %rdi
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0xb403(%rip), %xmm1     # 0xf008
divsd %xmm1, %xmm0
callq 0x34d0
movq %rax, -0x1e0(%rbp)
jmp 0x3c17
movq -0x1e0(%rbp), %rdi
leaq 0xb41b(%rip), %rsi      # 0xf040
callq 0x3250
jmp 0x3c2c
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x3270
jmp 0x3c41
movq -0x1d0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x1c0(%rbp), %rsi
callq 0x3a80
jmp 0x3c5a
leaq -0x1c0(%rbp), %rdi
callq 0x3190
leaq -0x190(%rbp), %rdi
callq 0x30a0
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x3cb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3190
leaq -0x190(%rbp), %rdi
callq 0x30a0
movq -0x198(%rbp), %rdi
callq 0x3480
nopl (%rax)
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: parseHourMin(HourMin*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool parseHourMin(HourMin* result, const std::string& s)
{
   std::vector<std::string> ss = splitIntoTokens(s, ".:");
   if (ss.size() != 2)
      return false;
   unsigned h,m;
   try
   {
      h = std::stoi(ss[0]);
      m = std::stoi(ss[1]);
   }
   catch (std::exception&)
   {
      return false;
   }
   if (m > 59)
      return false;
   if (h > 47)  // We shall allow 26 instead of 2am the next day but there is a limit
      return false;
   if (result != 0)
      *result = HourMin(h, m);
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq 0xb101(%rip), %rdx      # 0xf0e3
leaq 0xb2c1(%rip), %rcx      # 0xf2aa
callq 0x3cd0
leaq -0x30(%rbp), %rdi
callq 0x7210
cmpq $0x2, %rax
je 0x400d
movb $0x0, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x4105
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7270
movq -0x70(%rbp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x7230
movl %eax, -0x64(%rbp)
jmp 0x4034
movl -0x64(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x7270
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x7230
movl %eax, -0x74(%rbp)
jmp 0x405e
movl -0x74(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x40b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x411c
movq -0x48(%rbp), %rdi
callq 0x3100
movq %rax, -0x58(%rbp)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
callq 0x3450
jmp 0x40a1
jmp 0x4105
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x411c
cmpl $0x3b, -0x3c(%rbp)
jbe 0x40c4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x4105
cmpl $0x2f, -0x38(%rbp)
jbe 0x40d7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x4105
cmpq $0x0, -0x10(%rbp)
je 0x40fa
movl -0x38(%rbp), %esi
movl -0x3c(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x7290
jmp 0x40ef
movq -0x10(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x71b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x71b0
movq -0x48(%rbp), %rdi
callq 0x3480
nop
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: HourMin::operator<(HourMin const&) const
bool operator<(const HourMin& other) const
   {
      if (h < other.h)
         return true;
      if (h > other.h)
         return false;
      return m < other.m;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x7034
movb $0x1, -0x1(%rbp)
jmp 0x705e
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x7048
movb $0x0, -0x1(%rbp)
jmp 0x705e
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: MinutesMap::PersonMonStats::calcTotal() const
unsigned calcTotal() const
      {
         unsigned sum = 0;
         for (auto& it : s)
            sum += it.second;
         return sum;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7a00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7a60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7a30
testb $0x1, %al
jne 0x7ba8
jmp 0x7bcd
leaq -0x20(%rbp), %rdi
callq 0xc1f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x20(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7b30
jmp 0x7b95
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: MinutesMap::PersonMonStats::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
void update(const std::string& tow, unsigned minutes)
      {
         auto mi = s.find(tow);
         if (mi != s.end())
            mi->second += minutes;
         else
            s[tow] = minutes;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb2b0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x7db0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7d80
testb $0x1, %al
jne 0xa368
jmp 0xa382
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7de0
movl -0x34(%rbp), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
jmp 0xa39a
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb2e0
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: Neurochrom[P]hours_calc/hours_calc.cpp
// Function: YearMon::operator<(YearMon const&) const
bool operator<(const YearMon& other) const
   {
      if (y < other.y)
         return true;
      if (y > other.y)
         return false;
      return m < other.m;
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa814
movb $0x1, -0x1(%rbp)
jmp 0xa83e
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0xa828
movb $0x0, -0x1(%rbp)
jmp 0xa83e
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ncbi[P]amr/stx/fasta_extract.cpp
// Function: (anonymous namespace)::Segment::saveText(std::ostream&) const
void saveText (ostream &os) const
    { os         << start 
         << '\t' << stop 
         << '\t' << strand 
         << '\t' << genesymbol 
         << '\t' << name
         << endl;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xc150
movq %rax, %rdi
movl $0x9, %esi
callq 0xc810
movq %rax, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xc150
movq %rax, %rdi
movl $0x9, %esi
callq 0xc810
movq %rax, %rdi
movq (%rsp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xcc90
movq %rax, %rdi
movl $0x9, %esi
callq 0xc810
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
callq 0xc620
movq %rax, %rdi
movl $0x9, %esi
callq 0xc810
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x38, %rsi
callq 0xc620
movq %rax, %rdi
movq 0xa7e4a(%rip), %rsi     # 0xb6f50
callq 0xc700
addq $0x18, %rsp
retq
// File: ncbi[P]amr/stx/fasta_extract.cpp
// Function: (anonymous namespace)::complementaryNucleotide(char)
char complementaryNucleotide (char wildNucleotide)
{
  char r = ' ';
  switch (toLower (wildNucleotide))
  {
    case 'a': r = 't'; break;
    case 'c': r = 'g'; break;
    case 'g': r = 'c'; break;
    case 't': r = 'a'; break;
    case 'm': r = 'k'; break;
    case 'r': r = 'y'; break;
    case 'w': r = 'w'; break;
    case 's': r = 's'; break;
    case 'y': r = 'r'; break;
    case 'k': r = 'm'; break;
    case 'v': r = 'b'; break;
    case 'h': r = 'd'; break;
    case 'd': r = 'h'; break;
    case 'b': r = 'v'; break;
    case 'n': r = 'n'; break;
    case '-': r = '-'; break;
    default: 
    	throw runtime_error ("Bad nucleotide " + to_string (wildNucleotide));
  }
  if (isupper (wildNucleotide))
    r = toUpper (r);

  return r;
}

// Assembly:
subq $0x68, %rsp
movb %dil, %al
movb %al, 0x67(%rsp)
movb $0x20, 0x66(%rsp)
movsbl 0x67(%rsp), %edi
callq 0x14d10
movsbl %al, %eax
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4c, %eax
ja 0x121c5
movq 0x8(%rsp), %rax
leaq 0x78ee8(%rip), %rcx     # 0x8b004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x74, 0x66(%rsp)
jmp 0x12288
movb $0x67, 0x66(%rsp)
jmp 0x12288
movb $0x63, 0x66(%rsp)
jmp 0x12288
movb $0x61, 0x66(%rsp)
jmp 0x12288
movb $0x6b, 0x66(%rsp)
jmp 0x12288
movb $0x79, 0x66(%rsp)
jmp 0x12288
movb $0x77, 0x66(%rsp)
jmp 0x12288
movb $0x73, 0x66(%rsp)
jmp 0x12288
movb $0x72, 0x66(%rsp)
jmp 0x12288
movb $0x6d, 0x66(%rsp)
jmp 0x12288
movb $0x62, 0x66(%rsp)
jmp 0x12288
movb $0x64, 0x66(%rsp)
jmp 0x12288
movb $0x68, 0x66(%rsp)
jmp 0x12288
movb $0x76, 0x66(%rsp)
jmp 0x12288
movb $0x6e, 0x66(%rsp)
jmp 0x12288
movb $0x2d, 0x66(%rsp)
jmp 0x12288
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0xc380
movq %rax, (%rsp)
movsbl 0x67(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x14150
jmp 0x121e9
leaq 0x79390(%rip), %rsi     # 0x8b580
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x14350
jmp 0x12201
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xcb40
jmp 0x12211
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0xa4dc7(%rip), %rsi     # 0xb6fe8
movq 0xa4d48(%rip), %rdx     # 0xb6f70
callq 0xcc10
jmp 0x122b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x12274
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x1226a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xce28
leaq 0x20(%rsp), %rdi
callq 0xce28
testb $0x1, 0x13(%rsp)
jne 0x1227d
jmp 0x12286
movq (%rsp), %rdi
callq 0xc530
jmp 0x122ae
movsbl 0x67(%rsp), %edi
callq 0xc550
cmpl $0x0, %eax
je 0x122a5
movsbl 0x66(%rsp), %edi
callq 0x14d30
movb %al, 0x66(%rsp)
movb 0x66(%rsp), %al
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xcc70
nopl (%rax,%rax)
// File: shirookad[P]propcpp/main.cpp
// Function: measure_block(std::function<void ()> const&)
inline auto measure_block(const std::function<void ()> &f) {
	std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
	start = std::chrono::high_resolution_clock::now();
	f();
	end = std::chrono::high_resolution_clock::now();
	return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3ba0
leaq -0x18(%rbp), %rdi
callq 0x3ba0
callq 0x2040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3bd0
callq 0x2040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3c40
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3c10
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3c90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shirookad[P]propcpp/include/prop.h
// Function: prop::observable_property<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline T& set(const param_t value) {
			willSet(value);
			T oldValue = std::move(m_value);
			m_value = value;
			didSet(oldValue);
			return m_value;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x58b0
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2030
jmp 0x3a71
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
leaq -0x30(%rbp), %rsi
callq 0x58b0
jmp 0x3a84
leaq -0x30(%rbp), %rdi
callq 0x20b0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
callq 0x2140
nopw %cs:(%rax,%rax)
nop
// File: mrlordkaj[P]i2cdevlib-pi/AD7746/AD7746.cpp
// Function: AD7746::getCapacitance()
uint32_t AD7746::getCapacitance() {
    uint32_t capacitance;
    I2Cdev::readBytes(devAddr, 0, 4, buffer);
    capacitance = ((uint32_t)buffer[1] << 16) | ((uint32_t)buffer[2] << 8) | (uint32_t)buffer[3];
    
    return capacitance;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
xorl %esi, %esi
movl $0x4, %edx
movq 0x38091(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
shll $0x10, %eax
movzbl 0x3(%rcx), %edx
shll $0x8, %edx
orl %edx, %eax
movzbl 0x4(%rcx), %ecx
orl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::initialize()
void ADS1115::initialize() {
  setMultiplexer(ADS1115_MUX_P0_N1);
  setGain(ADS1115_PGA_2P048);
  setMode(ADS1115_MODE_SINGLESHOT);
  setRate(ADS1115_RATE_128);
  setComparatorMode(ADS1115_COMP_MODE_HYSTERESIS);
  setComparatorPolarity(ADS1115_COMP_POL_ACTIVE_LOW);
  setComparatorLatchEnabled(ADS1115_COMP_LAT_NON_LATCHING);
  setComparatorQueueMode(ADS1115_COMP_QUE_DISABLE);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x22260
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x22b40
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x232c0
movq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x232a0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x220c0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x23020
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x230c0
movq 0x8(%rsp), %rdi
movl $0x3, %esi
callq 0x22c30
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::setMultiplexer(unsigned char)
void ADS1115::setMultiplexer(uint8_t mux) {
    if (I2Cdev::writeBitsW(devAddr, ADS1115_RA_CONFIG, ADS1115_CFG_MUX_BIT, ADS1115_CFG_MUX_LENGTH, mux)) {
        muxMode = mux;
        if (devMode == ADS1115_MODE_CONTINUOUS) {
          // Force a stop/start
          setMode(ADS1115_MODE_SINGLESHOT);
          getConversion();
          setMode(ADS1115_MODE_CONTINUOUS);
        }
    }
    
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb (%rax), %dil
movzbl 0xf(%rsp), %eax
movl $0x1, %esi
movl $0xe, %edx
movl $0x3, %ecx
movzbl %dil, %edi
movzwl %ax, %r8d
callq 0x22570
testb $0x1, %al
jne 0x240d3
jmp 0x24114
movq (%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x7(%rax)
movb 0x6(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x24112
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x232c0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x22e90
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x232c0
jmp 0x24114
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::setGain(unsigned char)
void ADS1115::setGain(uint8_t gain) {
    if (I2Cdev::writeBitsW(devAddr, ADS1115_RA_CONFIG, ADS1115_CFG_PGA_BIT, ADS1115_CFG_PGA_LENGTH, gain)) {
      pgaMode = gain;
         if (devMode == ADS1115_MODE_CONTINUOUS) {
            // Force a stop/start
            setMode(ADS1115_MODE_SINGLESHOT);
            getConversion();
            setMode(ADS1115_MODE_CONTINUOUS);
         }
    }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb (%rax), %dil
movzbl 0xf(%rsp), %eax
movl $0x1, %esi
movl $0xb, %edx
movl $0x3, %ecx
movzbl %dil, %edi
movzwl %ax, %r8d
callq 0x22570
testb $0x1, %al
jne 0x24163
jmp 0x241a4
movq (%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x8(%rax)
movb 0x6(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x241a2
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x232c0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x22e90
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x232c0
jmp 0x241a4
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::getConversion(bool)
int16_t ADS1115::getConversion(bool triggerAndPoll) {
    if (triggerAndPoll && devMode == ADS1115_MODE_SINGLESHOT) {
      triggerConversion();
      pollConversion(I2CDEV_DEFAULT_READ_TIMEOUT);
    }
    I2Cdev::readWord(devAddr, ADS1115_RA_CONVERSION, buffer);
    return buffer[0];
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xf(%rsp)
je 0x2448a
movq (%rsp), %rax
movb 0x6(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2448a
movq (%rsp), %rdi
callq 0x22b80
movq (%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x22870
movq (%rsp), %rdx
movb (%rdx), %cl
addq $0x2, %rdx
xorl %esi, %esi
movq 0x37a7b(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22c40
movq (%rsp), %rax
movw 0x2(%rax), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::getMilliVolts(bool)
float ADS1115::getMilliVolts(bool triggerAndPoll) {
  switch (pgaMode) { 
    case ADS1115_PGA_6P144:
      return (getConversion(triggerAndPoll) * ADS1115_MV_6P144);
      break;    
    case ADS1115_PGA_4P096:
      return (getConversion(triggerAndPoll) * ADS1115_MV_4P096);
      break;             
    case ADS1115_PGA_2P048:    
      return (getConversion(triggerAndPoll) * ADS1115_MV_2P048);
      break;       
    case ADS1115_PGA_1P024:     
      return (getConversion(triggerAndPoll) * ADS1115_MV_1P024);
      break;       
    case ADS1115_PGA_0P512:      
      return (getConversion(triggerAndPoll) * ADS1115_MV_0P512);
      break;       
    case ADS1115_PGA_0P256:           
    case ADS1115_PGA_0P256B:          
    case ADS1115_PGA_0P256C:      
      return (getConversion(triggerAndPoll) * ADS1115_MV_0P256);
      break;       
  }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movzbl 0x8(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x7, %rax
ja 0x24846
movq 0x8(%rsp), %rax
leaq 0x26916(%rip), %rcx     # 0x4b030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22e90
cwtl
cvtsi2sd %eax, %xmm0
movsd 0x268e6(%rip), %xmm1    # 0x4b028
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x24848
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22e90
cwtl
cvtsi2sd %eax, %xmm0
movsd 0x268ac(%rip), %xmm1    # 0x4b020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x24848
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22e90
cwtl
cvtsi2sd %eax, %xmm0
movsd 0x26872(%rip), %xmm1    # 0x4b018
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x24848
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22e90
cwtl
cvtsi2sd %eax, %xmm0
movsd 0x26838(%rip), %xmm1    # 0x4b010
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x24848
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22e90
cwtl
cvtsi2sd %eax, %xmm0
movsd 0x26801(%rip), %xmm1    # 0x4b008
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x24848
movq (%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22e90
cwtl
cvtsi2sd %eax, %xmm0
movsd 0x267ca(%rip), %xmm1    # 0x4b000
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x24848
ud2
movss 0x24(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::getMvPerCount()
float ADS1115::getMvPerCount() {
  switch (pgaMode) {
    case ADS1115_PGA_6P144:
      return ADS1115_MV_6P144;
      break;    
    case ADS1115_PGA_4P096:
      return  ADS1115_MV_4P096;
      break;             
    case ADS1115_PGA_2P048:    
      return ADS1115_MV_2P048;
      break;       
    case ADS1115_PGA_1P024:     
      return ADS1115_MV_1P024;
      break;       
    case ADS1115_PGA_0P512:      
      return ADS1115_MV_0P512;
      break;       
    case ADS1115_PGA_0P256:           
    case ADS1115_PGA_0P256B:          
    case ADS1115_PGA_0P256C:      
      return ADS1115_MV_0P256;
      break;       
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl 0x8(%rax), %eax
movq %rax, -0x18(%rsp)
subq $0x7, %rax
ja 0x248ee
movq -0x18(%rsp), %rax
leaq 0x267cb(%rip), %rcx     # 0x4b050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss 0x267ee(%rip), %xmm0    # 0x4b084
movss %xmm0, -0x4(%rsp)
jmp 0x248f0
movss 0x267da(%rip), %xmm0    # 0x4b080
movss %xmm0, -0x4(%rsp)
jmp 0x248f0
movss 0x267c6(%rip), %xmm0    # 0x4b07c
movss %xmm0, -0x4(%rsp)
jmp 0x248f0
movss 0x267b2(%rip), %xmm0    # 0x4b078
movss %xmm0, -0x4(%rsp)
jmp 0x248f0
movss 0x2679e(%rip), %xmm0    # 0x4b074
movss %xmm0, -0x4(%rsp)
jmp 0x248f0
movss 0x2678a(%rip), %xmm0    # 0x4b070
movss %xmm0, -0x4(%rsp)
jmp 0x248f0
ud2
movss -0x4(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: ADS1115::setConversionReadyPinMode()
void ADS1115::setConversionReadyPinMode() {
    I2Cdev::writeBitW(devAddr, ADS1115_RA_HI_THRESH, 15, 1);
    I2Cdev::writeBitW(devAddr, ADS1115_RA_LO_THRESH, 15, 0);
    setComparatorPolarity(0);
    setComparatorQueueMode(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x3, %esi
movl $0xf, %edx
movl $0x1, %ecx
movzbl (%rax), %edi
callq 0x22e10
movq 0x8(%rsp), %rax
movl $0x2, %esi
movl $0xf, %edx
xorl %ecx, %ecx
movzbl (%rax), %edi
callq 0x22e10
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x23020
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x22c30
addq $0x18, %rsp
retq
// File: mrlordkaj[P]i2cdevlib-pi/ADS1115/ADS1115.cpp
// Function: createMask(unsigned int, unsigned int)
unsigned createMask(unsigned a, unsigned b) {
   unsigned mask = 0;
   for (unsigned i=a; i<=b; i++)
       mask |= 1 << i;
   return mask;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x8(%rsp), %eax
ja 0x24d32
movl -0x10(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x24d08
movl -0xc(%rsp), %eax
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADXL345/ADXL345.cpp
// Function: ADXL345::getOffset(signed char*, signed char*, signed char*)
void ADXL345::getOffset(int8_t* x, int8_t* y, int8_t* z) {
    I2Cdev::readBytes(devAddr, ADXL345_RA_OFSX, 3, buffer);
    *x = buffer[0];
    *y = buffer[1];
    *z = buffer[2];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x1e, %esi
movl $0x3, %edx
movq 0x36eff(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x1(%rax), %dl
movq 0x18(%rsp), %rcx
movb %dl, (%rcx)
movb 0x2(%rax), %dl
movq 0x10(%rsp), %rcx
movb %dl, (%rcx)
movb 0x3(%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/ADXL345/ADXL345.cpp
// Function: ADXL345::getAcceleration(short*, short*, short*)
void ADXL345::getAcceleration(int16_t* x, int16_t* y, int16_t* z) {
    I2Cdev::readBytes(devAddr, ADXL345_RA_DATAX0, 6, buffer);
    *x = (((int16_t)buffer[1]) << 8) | buffer[0];
    *y = (((int16_t)buffer[3]) << 8) | buffer[2];
    *z = (((int16_t)buffer[5]) << 8) | buffer[4];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x32, %esi
movl $0x6, %edx
movq 0x34e1f(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x4(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0x6(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/AK8963/AK8963.cpp
// Function: AK8963::getAdjustment(signed char*, signed char*, signed char*)
void AK8963::getAdjustment(int8_t *x, int8_t *y, int8_t *z) {
    I2Cdev::readBytes(devAddr, AK8963_RA_ASAX, 3, buffer);
    *x = buffer[0];
    *y = buffer[1];
    *z = buffer[2];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x10, %esi
movl $0x3, %edx
movq 0x344af(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x1(%rax), %dl
movq 0x18(%rsp), %rcx
movb %dl, (%rcx)
movb 0x2(%rax), %dl
movq 0x10(%rsp), %rcx
movb %dl, (%rcx)
movb 0x3(%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)