From 78913355d4e9caa7e6001d18c3e4603d41bdbf1c Mon Sep 17 00:00:00 2001
From: Kai Zhao <loverszhaokai@qq.com>
Date: Wed, 1 Apr 2015 23:57:31 +0800
Subject: [PATCH 3/3] calculate execution time

---
 src/7z_fmt_plug.c        |  47 +++++++---
 src/batch.c              |  18 ++++
 src/calculate_exe_time.h |  20 +++++
 src/cracker.c            | 134 +++++++++++++++++++---------
 src/formats.c            | 144 +++++++++++++++++-------------
 src/john.c               | 218 ++++++++++++++++++++++++++++++++++-----------
 src/loader.c             | 223 +++++++++++++++++++++++++++++++++++++----------
 src/wordlist.c           |  80 ++++++++++++-----
 8 files changed, 656 insertions(+), 228 deletions(-)
 create mode 100644 src/calculate_exe_time.h

diff --git a/src/7z_fmt_plug.c b/src/7z_fmt_plug.c
index 2d9cb60..c030440 100644
--- a/src/7z_fmt_plug.c
+++ b/src/7z_fmt_plug.c
@@ -34,6 +34,8 @@ john_register_one(&fmt_sevenzip);
 #include "unicode.h"
 #include "memdbg.h"
 
+#include "calculate_exe_time.h"
+
 #define FORMAT_LABEL		"7z"
 #define FORMAT_NAME		"7-Zip"
 #define FORMAT_TAG		"$7z$"
@@ -81,6 +83,8 @@ static struct custom_salt {
 
 static void init(struct fmt_main *self)
 {
+	CALCULATE_EXE_TIME
+
 	CRC32_t crc;
 #if defined (_OPENMP)
 	int omp_t = 1;
@@ -95,6 +99,8 @@ static void init(struct fmt_main *self)
 	cracked   = mem_calloc(self->params.max_keys_per_crypt,
 	                       sizeof(*cracked));
 	CRC32_Init(&crc);
+
+	CET_BEFORE_RETURN
 }
 
 static void done(void)
@@ -105,11 +111,13 @@ static void done(void)
 
 static int valid(char *ciphertext, struct fmt_main *self)
 {
+	CALCULATE_EXE_TIME
+
 	char *ctcopy, *keeptr, *p;
 	int len, NumCyclesPower;
 
 	if (strncmp(ciphertext, FORMAT_TAG, TAG_LENGTH) != 0)
-		return 0;
+		{ CET_BEFORE_RETURN return 0;}
 
 	ctcopy = strdup(ciphertext);
 	keeptr = ctcopy;
@@ -162,15 +170,17 @@ static int valid(char *ciphertext, struct fmt_main *self)
 		goto err;
 
 	MEM_FREE(keeptr);
-	return 1;
+	{ CET_BEFORE_RETURN return 1;}
 
 err:
 	MEM_FREE(keeptr);
-	return 0;
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 static void *get_salt(char *ciphertext)
 {
+	CALCULATE_EXE_TIME
+
 	char *ctcopy = strdup(ciphertext);
 	char *keeptr = ctcopy;
 	int i;
@@ -209,7 +219,7 @@ static void *get_salt(char *ciphertext)
 		cs->data[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
 			+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
 	MEM_FREE(keeptr);
-	return (void *)cs;
+	{ CET_BEFORE_RETURN return (void *)cs; }
 }
 
 static void set_salt(void *salt)
@@ -226,6 +236,8 @@ static int validFolder(unsigned char *data)
 
 static int sevenzip_decrypt(unsigned char *derived_key, unsigned char *data)
 {
+	CALCULATE_EXE_TIME
+
 #ifdef _MSC_VER
 	unsigned char *out;
 #else
@@ -263,7 +275,7 @@ static int sevenzip_decrypt(unsigned char *derived_key, unsigned char *data)
 #ifdef _MSC_VER
 			MEM_FREE(out);
 #endif
-			return -1;
+			{ CET_BEFORE_RETURN return -1; }
 		}
 		nbytes--;
 		i--;
@@ -274,7 +286,7 @@ static int sevenzip_decrypt(unsigned char *derived_key, unsigned char *data)
 #ifdef _MSC_VER
 			MEM_FREE(out);
 #endif
-		return 0;
+			{ CET_BEFORE_RETURN return 0; }
 	}
 
 	// test 1, CRC test
@@ -289,7 +301,7 @@ static int sevenzip_decrypt(unsigned char *derived_key, unsigned char *data)
 #ifdef _MSC_VER
 		MEM_FREE(out);
 #endif
-		return 0;  // XXX don't be too eager!
+		{ CET_BEFORE_RETURN return 0;}  // XXX don't be too eager!
 	}
 
 	// XXX test 2, "well-formed folder" test
@@ -298,19 +310,20 @@ static int sevenzip_decrypt(unsigned char *derived_key, unsigned char *data)
 #ifdef _MSC_VER
 		MEM_FREE(out);
 #endif
-		return 0;
+		{ CET_BEFORE_RETURN return 0;}
 	}
 
 #ifdef _MSC_VER
 	MEM_FREE(out);
 #endif
-	return -1;
+	{ CET_BEFORE_RETURN return -1;}
 }
 
 
 
 void sevenzip_kdf(UTF8 *password, unsigned char *master)
 {
+	CALCULATE_EXE_TIME
 	int len;
 	long long rounds = (long long) 1 << cur_salt->NumCyclesPower;
 	long long round;
@@ -344,10 +357,14 @@ void sevenzip_kdf(UTF8 *password, unsigned char *master)
 #endif
 	}
 	SHA256_Final(master, &sha);
+
+	CET_BEFORE_RETURN
 }
 
 static int crypt_all(int *pcount, struct db_salt *salt)
 {
+	CALCULATE_EXE_TIME
+
 	const int count = *pcount;
 	int index = 0;
 #ifdef _OPENMP
@@ -365,16 +382,18 @@ static int crypt_all(int *pcount, struct db_salt *salt)
 		else
 			cracked[index] = 0;
 	}
-	return count;
+	CET_BEFORE_RETURN return count;
 }
 
 static int cmp_all(void *binary, int count)
 {
+	CALCULATE_EXE_TIME
+
 	int index;
 	for (index = 0; index < count; index++)
 		if (cracked[index])
-			return 1;
-	return 0;
+			{ CET_BEFORE_RETURN return 1; }
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 static int cmp_one(void *binary, int index)
@@ -389,12 +408,16 @@ static int cmp_exact(char *source, int index)
 
 static void sevenzip_set_key(char *key, int index)
 {
+	CALCULATE_EXE_TIME
+
 	int saved_len = strlen(key);
 
 	if (saved_len > PLAINTEXT_LENGTH)
 		saved_len = PLAINTEXT_LENGTH;
 	memcpy(saved_key[index], key, saved_len);
 	saved_key[index][saved_len] = 0;
+
+	CET_BEFORE_RETURN
 }
 
 static char *get_key(int index)
diff --git a/src/batch.c b/src/batch.c
index a570f40..3bf6542 100644
--- a/src/batch.c
+++ b/src/batch.c
@@ -21,14 +21,22 @@
 #include "inc.h"
 #include "memdbg.h"
 
+#include "calculate_exe_time.h"
+
 static void do_single_pass(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	do_single_crack(db);
 	db->options->flags &= ~DB_WORDS; /* Might speed up pot sync */
+
+	CET_BEFORE_RETURN
 }
 
 static void do_wordlist_pass(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	char *name;
 
 	if (!(name = cfg_get_param(SECTION_OPTIONS, NULL, "Wordlist")))
@@ -36,15 +44,23 @@ static void do_wordlist_pass(struct db_main *db)
 		name = WORDLIST_NAME;
 
 	do_wordlist_crack(db, name, 1);
+
+	CET_BEFORE_RETURN
 }
 
 static void do_incremental_pass(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	do_incremental_crack(db, NULL);
+
+	CET_BEFORE_RETURN
 }
 
 void do_batch_crack(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	switch (status.pass) {
 	case 0:
 	case 1:
@@ -63,4 +79,6 @@ void do_batch_crack(struct db_main *db)
 		status.pass = 3;
 		do_incremental_pass(db);
 	}
+
+	CET_BEFORE_RETURN
 }
diff --git a/src/calculate_exe_time.h b/src/calculate_exe_time.h
new file mode 100644
index 0000000..a67f882
--- /dev/null
+++ b/src/calculate_exe_time.h
@@ -0,0 +1,20 @@
+#ifndef _CALCULATE_EXE_TIME_
+#define _CALCULATE_EXE_TIME_
+
+#include <time.h>
+#include <stdio.h>
+
+extern FILE *CET_file;
+
+#define CALCULATE_EXE_TIME static clock_t CET_start_time, CET_end_time; \
+	static float CET_expend_time, CET_total_expend_time;		\
+	static unsigned int CET_invoked_times = 0;			\
+	CET_start_time = clock();					\
+
+#define CET_BEFORE_RETURN CET_end_time = clock();				\
+	CET_expend_time = (float)(CET_end_time - CET_start_time) / CLOCKS_PER_SEC; \
+	CET_total_expend_time += CET_expend_time;			\
+	fprintf(CET_file, "===%s:%s()  invoked_times=%u  expend_time=%.4fs  total_expend_time=%.4fs\n", \
+	       __FILE__, __FUNCTION__, ++CET_invoked_times, CET_expend_time, CET_total_expend_time);
+
+#endif  // _CALCULATE_EXE_TIME_
diff --git a/src/cracker.c b/src/cracker.c
index f551269..8117398 100644
--- a/src/cracker.c
+++ b/src/cracker.c
@@ -62,6 +62,8 @@
 #endif
 #include "memdbg.h"
 
+#include "calculate_exe_time.h"
+
 #ifdef index
 #undef index
 #endif
@@ -95,18 +97,24 @@ static void crk_dummy_fix_state(void)
 
 static void crk_init_salt(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (!crk_db->salts->next) {
 		crk_methods.set_salt(crk_db->salts->salt);
 		crk_methods.set_salt = crk_dummy_set_salt;
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static void crk_help(void)
 {
+	CALCULATE_EXE_TIME
+
 	static int printed = 0;
 	if (!john_main_process || printed ||
 	    ((options.flags & FLG_STDOUT) && isatty(fileno(stdout))))
-		return;
+		{ CET_BEFORE_RETURN return; }
 #ifdef HAVE_MPI
 	if (mpi_p > 1 || getenv("OMPI_COMM_WORLD_SIZE"))
 #ifdef SIGUSR1
@@ -127,11 +135,15 @@ static void crk_help(void)
 	fprintf(stderr, "Press 'q' or Ctrl-C to abort, "
 	    "almost any other key for status\n");
 	printed = 1;
+
+	CET_BEFORE_RETURN
 }
 
 void crk_init(struct db_main *db, void (*fix_state)(void),
 	struct db_keys *guesses)
 {
+	CALCULATE_EXE_TIME
+
 	char *where;
 	size_t size;
 
@@ -183,6 +195,8 @@ void crk_init(struct db_main *db, void (*fix_state)(void),
 	crk_help();
 
 	idle_init(db->format);
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -191,6 +205,8 @@ void crk_init(struct db_main *db, void (*fix_state)(void),
  */
 static void crk_remove_salt(struct db_salt *salt)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt **current;
 
 	crk_db->salt_count--;
@@ -218,6 +234,8 @@ static void crk_remove_salt(struct db_salt *salt)
 		log_event("- got rid of a salt, %d left", crk_db->salt_count);
 #endif
 	dyna_salt_remove(salt->salt);
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -225,6 +243,8 @@ static void crk_remove_salt(struct db_salt *salt)
  */
 static void crk_remove_hash(struct db_salt *salt, struct db_password *pw)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_password **current;
 	int hash, count;
 
@@ -233,7 +253,7 @@ static void crk_remove_hash(struct db_salt *salt, struct db_password *pw)
 	if (!--salt->count) {
 		salt->list = NULL; /* "single crack" mode might care */
 		crk_remove_salt(salt);
-		return;
+		{ CET_BEFORE_RETURN return; }
 	}
 
 /*
@@ -246,7 +266,7 @@ static void crk_remove_hash(struct db_salt *salt, struct db_password *pw)
 			current = &(*current)->next;
 		*current = pw->next;
 		pw->binary = NULL;
-		return;
+		{ CET_BEFORE_RETURN return; }
 	}
 
 	hash = crk_db->format->methods.binary_hash[salt->hash_size](pw->binary);
@@ -279,12 +299,16 @@ static void crk_remove_hash(struct db_salt *salt, struct db_password *pw)
  * code in case that's what we're running, instead of traversing the list here.
  */
 	pw->binary = NULL;
+
+	CET_BEFORE_RETURN
 }
 
 /* Negative index is not counted/reported (got it from pot sync) */
 static int crk_process_guess(struct db_salt *salt, struct db_password *pw,
 	int index)
 {
+	CALCULATE_EXE_TIME
+
 	char utf8buf_key[PLAINTEXT_BUFFER_SIZE + 1];
 	char utf8login[PLAINTEXT_BUFFER_SIZE + 1];
 	char tmp8[PLAINTEXT_BUFFER_SIZE + 1];
@@ -363,22 +387,24 @@ static int crk_process_guess(struct db_salt *salt, struct db_password *pw,
 		crk_remove_hash(salt, pw);
 
 	if (!crk_db->salts)
-		return 1;
+		{ CET_BEFORE_RETURN return 1; }
 
 	crk_init_salt();
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0; }
 }
 
 static char *crk_loaded_counts(void)
 {
+	CALCULATE_EXE_TIME
+
 	static char s_loaded_counts[80];
 
 	if (crk_db->password_count == 0)
-		return "No remaining hashes";
+		{ CET_BEFORE_RETURN return "No remaining hashes"; }
 
 	if (crk_db->password_count == 1)
-		return "Remaining 1 hash";
+		{ CET_BEFORE_RETURN return "Remaining 1 hash"; }
 
 	sprintf(s_loaded_counts,
 		crk_db->salt_count > 1 ?
@@ -387,11 +413,13 @@ static char *crk_loaded_counts(void)
 		crk_db->password_count,
 		crk_db->salt_count);
 
-	return s_loaded_counts;
+	{ CET_BEFORE_RETURN return s_loaded_counts; }
 }
 
 static int crk_remove_pot_entry(char *ciphertext)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt *salt;
 	struct db_password *pw;
 	void *pot_salt;
@@ -408,7 +436,7 @@ static int crk_remove_pot_entry(char *ciphertext)
 	if (crk_db->salt_hash) {
 		salt = crk_db->salt_hash[crk_methods.salt_hash(pot_salt)];
 		if (!salt)
-			return 0;
+			{ CET_BEFORE_RETURN return 0; }
 	} else
 		salt = crk_db->salts;
 
@@ -423,7 +451,7 @@ static int crk_remove_pot_entry(char *ciphertext)
 #endif
 	dyna_salt_remove(pot_salt);
 	if (!salt)
-		return 0;
+		{ CET_BEFORE_RETURN return 0; }
 
 	if (!salt->bitmap) {
 		if ((pw = salt->list))
@@ -434,7 +462,7 @@ static int crk_remove_pot_entry(char *ciphertext)
 
 			if (!strcmp(source, ciphertext)) {
 				if (crk_process_guess(salt, pw, -1))
-					return 1;
+					{ CET_BEFORE_RETURN return 1;}
 
 				if (!(crk_db->options->flags & DB_WORDS))
 					break;
@@ -447,7 +475,7 @@ static int crk_remove_pot_entry(char *ciphertext)
 		hash = crk_methods.binary_hash[salt->hash_size](binary);
 		if (!(salt->bitmap[hash / (sizeof(*salt->bitmap) * 8)] &
 		      (1U << (hash % (sizeof(*salt->bitmap) * 8)))))
-			return 0;
+			{ CET_BEFORE_RETURN return 0;}
 
 		if ((pw = salt->hash[hash >> PASSWORD_HASH_SHR]))
 		do {
@@ -457,7 +485,7 @@ static int crk_remove_pot_entry(char *ciphertext)
 
 			if (!strcmp(source, ciphertext)) {
 				if (crk_process_guess(salt, pw, -1))
-					return 1;
+					{ CET_BEFORE_RETURN return 1;}
 
 				if (!(crk_db->options->flags & DB_WORDS))
 					break;
@@ -465,11 +493,13 @@ static int crk_remove_pot_entry(char *ciphertext)
 		} while ((pw = pw->next_hash));
 	}
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 int crk_reload_pot(void)
 {
+	CALCULATE_EXE_TIME
+
 	char line[LINE_BUFFER_SIZE], *fields[10];
 	FILE *pot_file;
 	int total = crk_db->password_count, others;
@@ -485,7 +515,7 @@ int crk_reload_pot(void)
 	event_reload = 0;
 
 	if (crk_params.flags & FMT_NOT_EXACT)
-		return 0;
+		{ CET_BEFORE_RETURN return 0;}
 
 	if (!(pot_file = fopen(path_expand(pers_opts.activepot), "rb")))
 		pexit("fopen: %s", path_expand(pers_opts.activepot));
@@ -580,12 +610,14 @@ int crk_reload_pot(void)
 	fprintf(stderr, "%s(%u): potsync removed %d hashes in %lu ms (%lu ms finding salts); %s\n", __FUNCTION__, options.node_min, others, 1000UL*(end - start)/CLK_TCK, 1000UL * salt_time / CLK_TCK, crk_loaded_counts());
 #endif
 
-	return (!crk_db->salts);
+	{ CET_BEFORE_RETURN return (!crk_db->salts);}
 }
 
 #ifdef HAVE_MPI
 static void crk_mpi_probe(void)
 {
+	CALCULATE_EXE_TIME
+
 	static MPI_Status s;
 	int flag;
 
@@ -598,11 +630,15 @@ static void crk_mpi_probe(void)
 		MPI_Irecv(buf, 1, MPI_CHAR, MPI_ANY_SOURCE,
 		          JOHN_MPI_RELOAD, MPI_COMM_WORLD, &r);
 	}
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 static void crk_poll_files(void)
 {
+	CALCULATE_EXE_TIME
+
 	struct stat trigger_stat;
 
 	if (options.abort_file &&
@@ -652,10 +688,14 @@ static void crk_poll_files(void)
 #endif
 		status.start_time -= (start - end);
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static int crk_process_event(void)
 {
+	CALCULATE_EXE_TIME
+
 	event_pending = 0;
 
 #ifdef HAVE_MPI
@@ -688,11 +728,13 @@ static int crk_process_event(void)
 		crk_poll_files();
 	}
 
-	return event_abort;
+	{ CET_BEFORE_RETURN return event_abort;}
 }
 
 static int crk_password_loop(struct db_salt *salt)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_password *pw;
 	int count, match, index;
 
@@ -703,7 +745,7 @@ static int crk_password_loop(struct db_salt *salt)
 	idle_yield();
 
 	if (event_pending && crk_process_event())
-		return -1;
+		{ CET_BEFORE_RETURN return -1;}
 
 	count = crk_key_index;
 	match = crk_methods.crypt_all(&count, salt);
@@ -716,7 +758,7 @@ static int crk_password_loop(struct db_salt *salt)
 	}
 
 	if (!match)
-		return 0;
+		{ CET_BEFORE_RETURN return 0;}
 
 	if (!salt->bitmap) {
 		pw = salt->list;
@@ -727,7 +769,7 @@ static int crk_password_loop(struct db_salt *salt)
 			if (crk_methods.cmp_exact(crk_methods.source(
 			    pw->source, pw->binary), index)) {
 				if (crk_process_guess(salt, pw, index))
-					return 1;
+					{ CET_BEFORE_RETURN return 1;}
 				else {
 					if (!(crk_params.flags & FMT_NOT_EXACT))
 						break;
@@ -745,21 +787,23 @@ static int crk_password_loop(struct db_salt *salt)
 				if (crk_methods.cmp_exact(crk_methods.source(
 				    pw->source, pw->binary), index))
 				if (crk_process_guess(salt, pw, index))
-					return 1;
+					{ CET_BEFORE_RETURN return 1;}
 			} while ((pw = pw->next_hash));
 		}
 	}
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 static int crk_salt_loop(void)
 {
+	CALCULATE_EXE_TIME
+
 	int done;
 	struct db_salt *salt;
 
 	if (event_reload && crk_reload_pot())
-		return 1;
+		{ CET_BEFORE_RETURN return 1;}
 
 	salt = crk_db->salts;
 	do {
@@ -780,7 +824,7 @@ static int crk_salt_loop(void)
 	}
 
 	if (salt)
-		return 1;
+		{ CET_BEFORE_RETURN return 1;}
 
 	crk_key_index = 0;
 	crk_last_salt = NULL;
@@ -798,11 +842,13 @@ static int crk_salt_loop(void)
 		status_print();
 	}
 
-	return ext_abort;
+	{ CET_BEFORE_RETURN return ext_abort;}
 }
 
 int crk_process_key(char *key)
 {
+	CALCULATE_EXE_TIME
+
 	if (crk_db->loaded) {
 		if (crk_key_index == 0)
 			crk_methods.clear_keys();
@@ -812,9 +858,9 @@ int crk_process_key(char *key)
 		if (crk_key_index >= crk_params.max_keys_per_crypt ||
 		    (options.force_maxkeys &&
 		     crk_key_index >= options.force_maxkeys))
-			return crk_salt_loop();
+			{ CET_BEFORE_RETURN return crk_salt_loop();}
 
-		return 0;
+		{ CET_BEFORE_RETURN return 0;}
 	}
 
 #if !OS_TIMER
@@ -822,7 +868,7 @@ int crk_process_key(char *key)
 #endif
 
 	if (event_pending)
-	if (crk_process_event()) return 1;
+		if (crk_process_event()) { CET_BEFORE_RETURN return 1;}
 
 	strnzcpy(crk_stdout_key, key, crk_params.plaintext_length + 1);
 	if (options.verbosity > 1)
@@ -844,12 +890,14 @@ int crk_process_key(char *key)
 		status_print();
 	}
 
-	return ext_abort;
+	{ CET_BEFORE_RETURN return ext_abort;}
 }
 
 /* This function is used by single.c only */
 int crk_process_salt(struct db_salt *salt)
 {
+	CALCULATE_EXE_TIME
+
 	char *ptr;
 	char key[PLAINTEXT_BUFFER_SIZE];
 	int count, count_from_guesses, index;
@@ -897,46 +945,54 @@ int crk_process_salt(struct db_salt *salt)
 					count_from_guesses -= index;
 			}
 			if (done)
-				return 1;
+				{ CET_BEFORE_RETURN return 1;}
 			if (!salt->list)
-				return 0;
+				{ CET_BEFORE_RETURN return 0;}
 			index = 0;
 		}
 	}
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 char *crk_get_key1(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (options.secure)
-		return "";
+		{ CET_BEFORE_RETURN return "";}
 	else
 	if (crk_db->loaded)
-		return crk_methods.get_key(0);
+		{ CET_BEFORE_RETURN return crk_methods.get_key(0);}
 	else
-		return crk_stdout_key;
+		{ CET_BEFORE_RETURN return crk_stdout_key;}
 }
 
 char *crk_get_key2(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (options.secure)
-		return NULL;
+		{ CET_BEFORE_RETURN return NULL;}
 	else
 	if (crk_key_index > 1 && crk_key_index < crk_last_key)
-		return crk_methods.get_key(crk_key_index - 1);
+		{ CET_BEFORE_RETURN return crk_methods.get_key(crk_key_index - 1);}
 	else
 	if (crk_last_key > 1)
-		return crk_methods.get_key(crk_last_key - 1);
+		{ CET_BEFORE_RETURN return crk_methods.get_key(crk_last_key - 1);}
 	else
-		return NULL;
+		{ CET_BEFORE_RETURN return NULL;}
 }
 
 void crk_done(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (crk_db->loaded) {
 		if (crk_key_index && crk_db->salts && !event_abort)
 			crk_salt_loop();
 	}
 	c_cleanup();
+
+	CET_BEFORE_RETURN
 }
diff --git a/src/formats.c b/src/formats.c
index 9b69a44..2a13dbe 100644
--- a/src/formats.c
+++ b/src/formats.c
@@ -33,6 +33,8 @@ typedef unsigned int ARCH_WORD_32;
 #include "jumbo.h"
 #include "memdbg.h"
 
+#include "calculate_exe_time.h"
+
 struct fmt_main *fmt_list = NULL;
 static struct fmt_main **fmt_tail = &fmt_list;
 
@@ -44,14 +46,19 @@ static int orig_min, orig_max, orig_len;
 
 void fmt_register(struct fmt_main *format)
 {
+CALCULATE_EXE_TIME
+
 	format->private.initialized = 0;
 	format->next = NULL;
 	*fmt_tail = format;
 	fmt_tail = &format->next;
+CET_BEFORE_RETURN
 }
 
 void fmt_init(struct fmt_main *format)
 {
+CALCULATE_EXE_TIME
+
 	char *opt;
 	if (!format->private.initialized) {
 		double d = 0;
@@ -103,10 +110,14 @@ void fmt_init(struct fmt_main *format)
 		error();
 	}
 #endif
+
+CET_BEFORE_RETURN
 }
 
 void fmt_done(struct fmt_main *format)
 {
+CALCULATE_EXE_TIME
+
 	if (format->private.initialized) {
 		format->methods.done();
 		format->private.initialized = 0;
@@ -120,6 +131,7 @@ void fmt_done(struct fmt_main *format)
 		}
 
 	}
+CET_BEFORE_RETURN
 }
 
 static int is_poweroftwo(size_t align)
@@ -146,6 +158,8 @@ static int is_aligned(void *p, size_t align)
 #define MAXLABEL_SIMD   "0X80_IS_NOT_EOW\x80" /* Catch a common bug */
 static char *longcand(struct fmt_main *format, int index, int ml)
 {
+CALCULATE_EXE_TIME
+
 	static char out[PLAINTEXT_BUFFER_SIZE];
 
 	memset(out, 'A' + (index % 23), ml);
@@ -162,6 +176,8 @@ static char *longcand(struct fmt_main *format, int index, int ml)
 static char *fmt_self_test_body(struct fmt_main *format,
     void *binary_copy, void *salt_copy)
 {
+CALCULATE_EXE_TIME
+
 	static char s_size[100];
 	struct fmt_tests *current;
 	char *ciphertext, *plaintext;
@@ -180,17 +196,18 @@ static char *fmt_self_test_body(struct fmt_main *format,
 	int ml;
 
 	// validate that there are no NULL function pointers
-	if (format->methods.prepare == NULL)    return "method prepare NULL";
-	if (format->methods.valid == NULL)      return "method valid NULL";
-	if (format->methods.split == NULL)      return "method split NULL";
-	if (format->methods.init == NULL)       return "method init NULL";
+	if (format->methods.prepare == NULL)    { CET_BEFORE_RETURN return "method prepare NULL"; }
+	if (format->methods.valid == NULL)      { CET_BEFORE_RETURN return "method valid NULL"; }
+	if (format->methods.split == NULL)      { CET_BEFORE_RETURN return "method split NULL"; }
+	if (format->methods.init == NULL)       { CET_BEFORE_RETURN return "method init NULL"; }
 
 /*
  * Test each format just once unless we're debugging.
  */
 #ifndef DEBUG
-	if (format->private.initialized == 2)
-		return NULL;
+	if (format->private.initialized == 2) {
+		CET_BEFORE_RETURN return NULL;
+	}
 #endif
 
 #ifndef BENCH_BUILD
@@ -200,14 +217,14 @@ static char *fmt_self_test_body(struct fmt_main *format,
 		format->methods.reset(NULL);
 		format->private.initialized = 2;
 		format->methods.clear_keys();
-		return NULL;
+		CET_BEFORE_RETURN return NULL;
 	}
 #endif
 
 	MemDbg_Validate_msg(MEMDBG_VALIDATE_DEEPEST,
 	                    "\nAt start of self-test:");
 
-	if (!(current = format->params.tests)) return NULL;
+	if (!(current = format->params.tests)) { CET_BEFORE_RETURN return NULL; }
 	ntests = 0;
 	while ((current++)->ciphertext)
 		ntests++;
@@ -222,50 +239,53 @@ static char *fmt_self_test_body(struct fmt_main *format,
 	}
 #endif
 
-	if (ntests==0) return NULL;
+	if (ntests==0) { CET_BEFORE_RETURN return NULL; }
 
 	/* Check prepare, valid, split before init */
 	if (!current->fields[1])
 		current->fields[1] = current->ciphertext;
 	ciphertext = format->methods.prepare(current->fields, format);
-	if (!ciphertext || strlen(ciphertext) < 7)
-		return "prepare (before init)";
-	if (format->methods.valid(ciphertext, format) != 1)
-		return "valid (before init)";
-	if (!format->methods.split(ciphertext, 0, format))
-		return "split() returned NULL (before init)";
+	if (!ciphertext || strlen(ciphertext) < 7) {
+		CET_BEFORE_RETURN return "prepare (before init)";
+	}
+	if (format->methods.valid(ciphertext, format) != 1) {
+		CET_BEFORE_RETURN return "valid (before init)";
+	}
+	if (!format->methods.split(ciphertext, 0, format)) {
+		CET_BEFORE_RETURN return "split() returned NULL (before init)";
+	}
 	fmt_init(format);
 
 	// validate that there are no NULL function pointers after init()
-	if (format->methods.done == NULL)       return "method done NULL";
-	if (format->methods.reset == NULL)      return "method reset NULL";
-	if (format->methods.binary == NULL)     return "method binary NULL";
-	if (format->methods.salt == NULL)       return "method salt NULL";
-	if (format->methods.source == NULL)     return "method source NULL";
-	if (!format->methods.binary_hash[0])    return "method binary_hash[0] NULL";
-	if (format->methods.salt_hash == NULL)  return "method salt_hash NULL";
-	if (format->methods.set_salt == NULL)   return "method set_salt NULL";
-	if (format->methods.set_key == NULL)    return "method set_key NULL";
-	if (format->methods.get_key == NULL)    return "method get_key NULL";
-	if (format->methods.clear_keys == NULL) return "method clear_keys NULL";
-	if (format->methods.crypt_all == NULL)  return "method crypt_all NULL";
-	if (format->methods.get_hash[0]==NULL)  return "method get_hash[0] NULL";
-	if (format->methods.cmp_all == NULL)    return "method cmp_all NULL";
-	if (format->methods.cmp_one == NULL)    return "method cmp_one NULL";
-	if (format->methods.cmp_exact == NULL)  return "method cmp_exact NULL";
+	if (format->methods.done == NULL)       { CET_BEFORE_RETURN return "method done NULL"; }
+	if (format->methods.reset == NULL)      { CET_BEFORE_RETURN return "method reset NULL"; }
+	if (format->methods.binary == NULL)     { CET_BEFORE_RETURN return "method binary NULL"; }
+	if (format->methods.salt == NULL)       { CET_BEFORE_RETURN return "method salt NULL"; }
+	if (format->methods.source == NULL)     { CET_BEFORE_RETURN return "method source NULL"; }
+	if (!format->methods.binary_hash[0])    { CET_BEFORE_RETURN return "method binary_hash[0] NULL"; }
+	if (format->methods.salt_hash == NULL)  { CET_BEFORE_RETURN return "method salt_hash NULL"; }
+	if (format->methods.set_salt == NULL)   { CET_BEFORE_RETURN return "method set_salt NULL";}
+	if (format->methods.set_key == NULL)    { CET_BEFORE_RETURN return "method set_key NULL";}
+	if (format->methods.get_key == NULL)    { CET_BEFORE_RETURN return "method get_key NULL";}
+	if (format->methods.clear_keys == NULL) { CET_BEFORE_RETURN return "method clear_keys NULL";}
+	if (format->methods.crypt_all == NULL)  { CET_BEFORE_RETURN return "method crypt_all NULL";}
+	if (format->methods.get_hash[0]==NULL)  { CET_BEFORE_RETURN return "method get_hash[0] NULL";}
+	if (format->methods.cmp_all == NULL)    { CET_BEFORE_RETURN return "method cmp_all NULL";}
+	if (format->methods.cmp_one == NULL)    { CET_BEFORE_RETURN return "method cmp_one NULL";}
+	if (format->methods.cmp_exact == NULL)  { CET_BEFORE_RETURN return "method cmp_exact NULL";}
 
 	if (format->params.plaintext_length < 1 ||
 	    format->params.plaintext_length > PLAINTEXT_BUFFER_SIZE - 3)
-		return "plaintext_length";
+		{ CET_BEFORE_RETURN return "plaintext_length"; }
 
 	if (!is_poweroftwo(format->params.binary_align))
-		return "binary_align";
+		{ CET_BEFORE_RETURN return "binary_align"; }
 
 	if (!is_poweroftwo(format->params.salt_align))
-		return "salt_align";
+		{ CET_BEFORE_RETURN return "salt_align"; }
 
 	if (format->methods.valid("*", format))
-		return "valid";
+		{ CET_BEFORE_RETURN return "valid"; }
 
 	ml = format->params.plaintext_length;
 #ifndef BENCH_BUILD
@@ -282,11 +302,11 @@ static char *fmt_self_test_body(struct fmt_main *format,
 
 	if ((format->methods.split == fmt_default_split) &&
 	    (format->params.flags & FMT_SPLIT_UNIFIES_CASE))
-		return "FMT_SPLIT_UNIFIES_CASE";
+		{ CET_BEFORE_RETURN return "FMT_SPLIT_UNIFIES_CASE"; }
 
 	if ((format->params.flags & FMT_OMP_BAD) &&
 	    !(format->params.flags & FMT_OMP))
-		return "FMT_OMP_BAD";
+		{ CET_BEFORE_RETURN return "FMT_OMP_BAD"; }
 
 	if ((format->methods.binary == fmt_default_binary) &&
 	    (format->params.binary_size > 0))
@@ -298,14 +318,14 @@ static char *fmt_self_test_body(struct fmt_main *format,
 		puts("Warning: Using default salt() with a non-zero SALT_SIZE");
 
 	if (format->params.min_keys_per_crypt < 1)
-		return "min keys per crypt";
+		{ CET_BEFORE_RETURN return "min keys per crypt"; }
 
 	if (format->params.max_keys_per_crypt < 1)
-		return "max keys per crypt";
+		{ CET_BEFORE_RETURN return "max keys per crypt"; }
 
 	if (format->params.max_keys_per_crypt <
 	    format->params.min_keys_per_crypt)
-		return "max < min keys per crypt";
+		{ CET_BEFORE_RETURN return "max < min keys per crypt"; }
 
 	done = 0;
 	index = 0; max = format->params.max_keys_per_crypt;
@@ -316,10 +336,10 @@ static char *fmt_self_test_body(struct fmt_main *format,
 		ciphertext = format->methods.prepare(current->fields, format);
 		if (!ciphertext || (strcmp(format->params.label, "plaintext") &&
 		                    strlen(ciphertext) < 7))
-			return "prepare";
+			{ CET_BEFORE_RETURN return "prepare"; }
 		if (format->methods.valid(ciphertext, format) != 1) {
 			snprintf(s_size, sizeof(s_size), "valid (%s)", ciphertext);
-			return s_size;
+			{ CET_BEFORE_RETURN return s_size; }
 		}
 
 #if !defined(BENCH_BUILD)
@@ -337,7 +357,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 						// $tag$ only
 						if (format->methods.valid(k, format)) {
 							sprintf(s_size, "promiscuous valid (%s)", k);
-							return s_size;
+							{ CET_BEFORE_RETURN return s_size; }
 						}
 						*p = '$';
 						while (*p)
@@ -345,7 +365,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 						// $tag$$$$$$$$$$$$$$$$$$
 						if (format->methods.valid(k, format)) {
 							sprintf(s_size, "promiscuous valid");
-							return s_size;
+							{ CET_BEFORE_RETURN return s_size; }
 						}
 						break;
 					}
@@ -357,7 +377,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 
 		ciphertext = format->methods.split(ciphertext, 0, format);
 		if (!ciphertext)
-			return "split() returned NULL";
+			{ CET_BEFORE_RETURN return "split() returned NULL"; }
 		plaintext = current->plaintext;
 
 /*
@@ -366,7 +386,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
  * returned by binary() and salt() only to the declared sizes.
  */
 		if (!(binary = format->methods.binary(ciphertext)))
-			return "binary() returned NULL";
+			{ CET_BEFORE_RETURN return "binary() returned NULL"; }
 #if ARCH_ALLOWS_UNALIGNED
 		if (mem_saving_level <= 2 || format->params.binary_align >= MEM_ALIGN_SIMD)
 #endif
@@ -404,7 +424,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 		salt = format->methods.salt(ciphertext);
 		dyna_salt_create(salt);
 		if (!salt)
-			return "salt() returned NULL";
+			{ CET_BEFORE_RETURN return "salt() returned NULL"; }
 #if ARCH_ALLOWS_UNALIGNED
 		if (mem_saving_level <= 2 || format->params.salt_align >= MEM_ALIGN_SIMD)
 #endif
@@ -488,11 +508,11 @@ static char *fmt_self_test_body(struct fmt_main *format,
 
 		if (strcmp(ciphertext,
 		    format->methods.source(ciphertext, binary)))
-			return "source";
+			{ CET_BEFORE_RETURN return "source"; }
 
 		if ((unsigned int)format->methods.salt_hash(salt) >=
 		    SALT_HASH_SIZE)
-			return "salt_hash";
+			{ CET_BEFORE_RETURN return "salt_hash"; }
 
 		format->methods.set_salt(salt);
 
@@ -533,7 +553,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 					sprintf(s_size, "max. length in index "
 					        "%d: wrote %d, got %d back", i,
 					        ml, (int)strlen(getkey));
-					return s_size;
+					{ CET_BEFORE_RETURN return s_size; }
 				}
 			}
 		}
@@ -552,7 +572,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 
 			if (!format->methods.cmp_all(binary, match)) {
 				sprintf(s_size, "cmp_all(%d)", match);
-				return s_size;
+				{ CET_BEFORE_RETURN return s_size; }
 			}
 
 			for (i = match - 1; i >= 0; i--) {
@@ -562,7 +582,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 
 			if (i == -1) {
 				sprintf(s_size, "cmp_one(%d)", match);
-				return s_size;
+				{ CET_BEFORE_RETURN return s_size; }
 			}
 
 			for (size = 0; size < PASSWORD_HASH_SIZES; size++)
@@ -591,18 +611,18 @@ static char *fmt_self_test_body(struct fmt_main *format,
 				else
 					sprintf(s_size, "get_hash[%d](%d)", size, index);
 #endif
-				return s_size;
+				{ CET_BEFORE_RETURN return s_size; }
 			}
 
 			if (!format->methods.cmp_exact(ciphertext, i)) {
 				sprintf(s_size, "cmp_exact(%d)", i);
-				return s_size;
+				{ CET_BEFORE_RETURN return s_size; }
 			}
 
 			if (strncmp(format->methods.get_key(i), plaintext,
 				format->params.plaintext_length)) {
 				sprintf(s_size, "get_key(%d)", i);
-				return s_size;
+				{ CET_BEFORE_RETURN return s_size; }
 			}
 		}
 
@@ -658,7 +678,7 @@ static char *fmt_self_test_body(struct fmt_main *format,
 
 	MemDbg_Validate_msg(MEMDBG_VALIDATE_DEEPEST, "At end of self-test:");
 
-	return NULL;
+	{ CET_BEFORE_RETURN return NULL; }
 }
 
 /*
@@ -668,6 +688,8 @@ static char *fmt_self_test_body(struct fmt_main *format,
  */
 static void *alloc_binary(void **alloc, size_t size, size_t align)
 {
+CALCULATE_EXE_TIME
+
 	size_t mask = align - 1;
 	char *p;
 
@@ -680,11 +702,13 @@ static void *alloc_binary(void **alloc, size_t size, size_t align)
 	if (!((size_t)p & align))
 		p += align;
 
-	return p;
+	{ CET_BEFORE_RETURN return p; }
 }
 
 char *fmt_self_test(struct fmt_main *format)
 {
+CALCULATE_EXE_TIME
+
 	char *retval;
 	void *binary_alloc, *salt_alloc;
 	void *binary_copy, *salt_copy;
@@ -705,7 +729,7 @@ char *fmt_self_test(struct fmt_main *format)
 	MEM_FREE(salt_alloc);
 	MEM_FREE(binary_alloc);
 
-	return retval;
+	{ CET_BEFORE_RETURN return retval; }
 }
 
 void fmt_default_init(struct fmt_main *self)
@@ -792,6 +816,8 @@ int fmt_default_salt_hash(void *salt)
 
 int fmt_default_dyna_salt_hash(void *salt)
 {
+CALCULATE_EXE_TIME
+
 	/* if the hash is a dyna_salt type hash, it can simply use this function */
 	dyna_salt_john_core *mysalt = *(dyna_salt_john_core **)salt;
 	unsigned v;
@@ -812,7 +838,7 @@ int fmt_default_dyna_salt_hash(void *salt)
 #ifdef DYNA_SALT_DEBUG
 	fprintf(stderr, "fmt_default_dyna_salt_hash(): return %d\n", v & (SALT_HASH_SIZE - 1));
 #endif
-	return v & (SALT_HASH_SIZE - 1);
+	{ CET_BEFORE_RETURN return v & (SALT_HASH_SIZE - 1); }
 }
 
 void fmt_default_set_salt(void *salt)
diff --git a/src/john.c b/src/john.c
index 0c730ff..887c678 100644
--- a/src/john.c
+++ b/src/john.c
@@ -16,6 +16,7 @@
  * see doc/LICENSE.
  */
 
+
 #if AC_BUILT
 /* need to know if HAVE_LIBDL is set, for autoconfig build */
 #include "autoconfig.h"
@@ -99,6 +100,7 @@ static int john_omp_threads_new;
 #include "john-mpi.h"
 #endif
 #include "regex.h"
+#include "calculate_exe_time.h"
 
 #include "unicode.h"
 #include "plugin.h"
@@ -149,6 +151,7 @@ extern struct fmt_main fmt_cuda_rawsha224;
 extern struct fmt_main fmt_cuda_rawsha256;
 #endif
 
+
 extern int unshadow(int argc, char **argv);
 extern int unafs(int argc, char **argv);
 extern int unique(int argc, char **argv);
@@ -184,8 +187,12 @@ static struct fmt_main dummy_format;
 
 static int exit_status = 0;
 
+FILE *CET_file; // Used to calculate execution time of all the functions
+
 static void john_register_one(struct fmt_main *format)
 {
+	CALCULATE_EXE_TIME
+
 	if (options.format) {
 		char *pos = strchr(options.format, '*');
 
@@ -198,69 +205,104 @@ static void john_register_one(struct fmt_main *format)
 		if (pos) {
 			// Wildcard, as in office*
 			if (strncasecmp(format->params.label, options.format,
-			                (int)(pos - options.format))) return;
+			                (int)(pos - options.format))) { 
+				CET_BEFORE_RETURN return;
+			}
 			// Trailer wildcard, as in *office or raw*ng
 			if (pos[1]) {
 				int wild_len = strlen(++pos);
 				int label_len = strlen(format->params.label);
 				const char *p;
 
-				if (wild_len > label_len)
-					return;
+				if (wild_len > label_len) {
+					CET_BEFORE_RETURN return;
+				}
 
 				p = &format->params.label[label_len - wild_len];
 
-				if (strcasecmp(p, pos))
-					return;
+				if (strcasecmp(p, pos)) {
+					CET_BEFORE_RETURN return;
+				}
 			}
 		}
 		else if (!strcasecmp(options.format, "dynamic")) {
-			if ( (format->params.flags & FMT_DYNAMIC) == 0) return;
+			if ( (format->params.flags & FMT_DYNAMIC) == 0) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "cpu")) {
 			if (strstr(format->params.label, "-opencl") ||
-			    strstr(format->params.label, "-cuda")) return;
+			    strstr(format->params.label, "-cuda")) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "cpu-dynamic")) {
 			if (strstr(format->params.label, "-opencl") ||
-			    strstr(format->params.label, "-cuda")) return;
-			if ( (format->params.flags & FMT_DYNAMIC) == FMT_DYNAMIC) return;
+			    strstr(format->params.label, "-cuda")) { 
+				CET_BEFORE_RETURN return;
+			}
+			if ( (format->params.flags & FMT_DYNAMIC) == FMT_DYNAMIC) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "gpu")) {
 			if (!strstr(format->params.label, "-opencl") &&
-			    !strstr(format->params.label, "-cuda")) return;
+			    !strstr(format->params.label, "-cuda")) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "opencl")) {
-			if (!strstr(format->params.label, "-opencl")) return;
+			if (!strstr(format->params.label, "-opencl")) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "cuda")) {
-			if (!strstr(format->params.label, "-cuda")) return;
+			if (!strstr(format->params.label, "-cuda")) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 #ifdef _OPENMP
 		else if (!strcasecmp(options.format, "omp")) {
-			if ((format->params.flags & FMT_OMP) != FMT_OMP) return;
+			if ((format->params.flags & FMT_OMP) != FMT_OMP) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "cpu+omp")) {
-			if ((format->params.flags & FMT_OMP) != FMT_OMP) return;
+			if ((format->params.flags & FMT_OMP) != FMT_OMP) { 
+				CET_BEFORE_RETURN return;
+			}
 			if (strstr(format->params.label, "-opencl") ||
-			    strstr(format->params.label, "-cuda")) return;
+			    strstr(format->params.label, "-cuda")) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 		else if (!strcasecmp(options.format, "cpu+omp-dynamic")) {
-			if ((format->params.flags & FMT_OMP) != FMT_OMP) return;
+			if ((format->params.flags & FMT_OMP) != FMT_OMP) { 
+				CET_BEFORE_RETURN return;
+			}
 			if (strstr(format->params.label, "-opencl") ||
-			    strstr(format->params.label, "-cuda")) return;
-			if ( (format->params.flags & FMT_DYNAMIC) == FMT_DYNAMIC) return;
+			    strstr(format->params.label, "-cuda")) {
+				CET_BEFORE_RETURN return;
+			}
+			if ( (format->params.flags & FMT_DYNAMIC) == FMT_DYNAMIC) { 
+				CET_BEFORE_RETURN return;
+			}
 		}
 #endif
-		else if (strcasecmp(options.format, format->params.label))
-			return;
+		else if (strcasecmp(options.format, format->params.label)) {
+			CET_BEFORE_RETURN return;
+		}
 	}
 
 	fmt_register(format);
+
+	CET_BEFORE_RETURN
 }
 
 static void john_register_all(void)
 {
+	CALCULATE_EXE_TIME
+
 	int i, cnt;
 	struct fmt_main *selfs;
 
@@ -308,10 +350,14 @@ static void john_register_all(void)
 		fprintf(stderr, "Unknown ciphertext format name requested\n");
 		error();
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static void john_log_format(void)
 {
+	CALCULATE_EXE_TIME
+
 	int min_chunk, chunk;
 
 	/* make sure the format is properly initialized */
@@ -341,14 +387,20 @@ static void john_log_format(void)
 			"tried in chunks of %d",
 			min_chunk > 1 ? "will" : "may",
 			chunk);
+
+	CET_BEFORE_RETURN
 }
 
 #ifdef _OPENMP
 static void john_omp_init(void)
 {
+	CALCULATE_EXE_TIME
+
 	john_omp_threads_new = omp_get_max_threads();
 	if (!john_omp_threads_orig)
 		john_omp_threads_orig = john_omp_threads_new;
+
+	CET_BEFORE_RETURN
 }
 
 #if OMP_FALLBACK
@@ -357,17 +409,23 @@ static void john_omp_init(void)
 #endif
 #define HAVE_JOHN_OMP_FALLBACK
 static void john_omp_fallback(char **argv) {
+	CALCULATE_EXE_TIME
+
 	if (!getenv("JOHN_NO_OMP_FALLBACK") && john_omp_threads_new <= 1) {
 		rec_done(-2);
 #define OMP_FALLBACK_PATHNAME JOHN_SYSTEMWIDE_EXEC "/" OMP_FALLBACK_BINARY
 		execv(OMP_FALLBACK_PATHNAME, argv);
 		perror("execv: " OMP_FALLBACK_PATHNAME);
 	}
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 static void john_omp_maybe_adjust_or_fallback(char **argv)
 {
+	CALCULATE_EXE_TIME
+
 	if (options.fork && !getenv("OMP_NUM_THREADS")) {
 		john_omp_threads_new /= options.fork;
 		if (john_omp_threads_new < 1)
@@ -378,10 +436,14 @@ static void john_omp_maybe_adjust_or_fallback(char **argv)
 		john_omp_fallback(argv);
 #endif
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static void john_omp_show_info(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (options.verbosity > 2)
 #if HAVE_MPI
 	if (mpi_p == 1)
@@ -427,8 +489,9 @@ static void john_omp_show_info(void)
 		    (fmt_list->params.flags & FMT_OMP))
 			show = 1;
 
-		if (!show)
-			return;
+		if (!show) {
+			CET_BEFORE_RETURN return;
+		}
 	}
 
 #if HAVE_MPI
@@ -478,12 +541,16 @@ static void john_omp_show_info(void)
 	if (john_main_process)
 		fputs("Warning: OpenMP is disabled; "
 		    "a non-OpenMP build may be faster\n", stderr);
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 #if OS_FORK
 static void john_fork(void)
 {
+	CALCULATE_EXE_TIME
+
 	int i, pid;
 	int *pids;
 
@@ -547,7 +614,7 @@ static void john_fork(void)
 				options.node_min = options.node_max = node_id;
 			}
 			sig_init_child();
-			return;
+			CET_BEFORE_RETURN return;
 
 		default:
 			pids[i - 1] = pid;
@@ -575,6 +642,8 @@ static void john_fork(void)
 	john_child_count = options.fork - 1;
 
 	options.node_max = options.node_min;
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -584,6 +653,8 @@ static void john_fork(void)
 #if HAVE_MPI
 static void john_set_mpi(void)
 {
+	CALCULATE_EXE_TIME
+
 	options.node_min += mpi_id;
 	options.node_max = options.node_min;
 
@@ -603,11 +674,15 @@ static void john_set_mpi(void)
 	}
 	fflush(stdout);
 	fflush(stderr);
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 static void john_wait(void)
 {
+	CALCULATE_EXE_TIME
+
 	int waiting_for = john_child_count;
 
 	log_event("Waiting for %d child%s to terminate",
@@ -646,12 +721,16 @@ static void john_wait(void)
 
 /* Close and possibly remove our .rec file now */
 	rec_done((children_ok && !event_abort) ? -1 : -2);
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 #if HAVE_MPI
 static void john_mpi_wait(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (!database.password_count && !options.reload_at_crack) {
 		int i;
 
@@ -679,15 +758,20 @@ static void john_mpi_wait(void)
 
 /* Close and possibly remove our .rec file now */
 	rec_done(!event_abort ? -1 : -2);
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 static char *john_loaded_counts(void)
 {
+	CALCULATE_EXE_TIME
+
 	static char s_loaded_counts[80];
 
-	if (database.password_count == 1)
-		return "1 password hash";
+	if (database.password_count == 1) {
+		CET_BEFORE_RETURN return "1 password hash";
+	}
 
 	sprintf(s_loaded_counts,
 		database.salt_count > 1 ?
@@ -696,11 +780,13 @@ static char *john_loaded_counts(void)
 		database.password_count,
 		database.salt_count);
 
-	return s_loaded_counts;
+	CET_BEFORE_RETURN return s_loaded_counts;
 }
 
 static void john_load_conf(void)
 {
+	CALCULATE_EXE_TIME
+
 	int internal, target;
 
 	if (!(options.flags & FLG_VERBOSITY)) {
@@ -796,10 +882,14 @@ static void john_load_conf(void)
 	pers_opts.internal_enc = internal;
 	pers_opts.target_enc = target;
 	pers_opts.unicode_cp = CP_UNDEF;
+
+	CET_BEFORE_RETURN
 }
 
 static void john_load_conf_db(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (options.flags & FLG_STDOUT) {
 		/* john.conf alternative for --internal-encoding */
 		if (!pers_opts.internal_enc &&
@@ -873,10 +963,14 @@ static void john_load_conf_db(void)
 			fprintf(stderr, "Rules/masks using %s\n",
 			        cp_id2name(pers_opts.internal_enc));
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static void john_load(void)
 {
+	CALCULATE_EXE_TIME
+
 	struct list_entry *current;
 
 #ifndef _MSC_VER
@@ -903,7 +997,7 @@ static void john_load(void)
 			ldr_show_pot_file(&database, pers_opts.activepot);
 		}
 
-		return;
+		CET_BEFORE_RETURN return;
 	}
 
 	if (options.flags & FLG_STDOUT) {
@@ -951,7 +1045,7 @@ static void john_load(void)
 				database.password_count -
 				database.guess_count);
 
-			return;
+			CET_BEFORE_RETURN return;
 		}
 
 		if (options.flags & (FLG_SINGLE_CHK | FLG_BATCH_CHK) &&
@@ -1138,11 +1232,15 @@ static void john_load(void)
 			john_set_mpi();
 #endif
 	}
+
+	CET_BEFORE_RETURN
 }
 
 #if CPU_DETECT
 static void CPU_detect_or_fallback(char **argv, int make_check)
 {
+	CALCULATE_EXE_TIME
+
 	if (!CPU_detect()) {
 #if CPU_REQ
 #if CPU_FALLBACK
@@ -1162,6 +1260,8 @@ static void CPU_detect_or_fallback(char **argv, int make_check)
 		error();
 #endif
 	}
+
+	CET_BEFORE_RETURN
 }
 #else
 #define CPU_detect_or_fallback(argv, make_check)
@@ -1169,6 +1269,8 @@ static void CPU_detect_or_fallback(char **argv, int make_check)
 
 static void john_init(char *name, int argc, char **argv)
 {
+	CALCULATE_EXE_TIME
+
 	int show_usage = 0;
 	int make_check = (argc == 2 && !strcmp(argv[1], "--make_check"));
 	if (make_check)
@@ -1299,10 +1401,14 @@ static void john_init(char *name, int argc, char **argv)
 		log_event("- Rules/masks using %s",
 		          cp_id2name(pers_opts.internal_enc));
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static void john_run(void)
 {
+	CALCULATE_EXE_TIME
+
 	struct stat trigger_stat;
 	int trigger_reset = 0;
 
@@ -1453,10 +1559,13 @@ static void john_run(void)
 			    "the cracked passwords reliably\n", stderr);
 		}
 	}
+	CET_BEFORE_RETURN
 }
 
 static void john_done(void)
 {
+	CALCULATE_EXE_TIME
+
 	if ((options.flags & (FLG_CRACKING_CHK | FLG_STDOUT)) ==
 	    FLG_CRACKING_CHK) {
 		if (event_abort) {
@@ -1506,16 +1615,22 @@ static void john_done(void)
 
 	check_abort(0);
 	cleanup_tiny_memory();
+
+	CET_BEFORE_RETURN
 }
 
 int main(int argc, char **argv)
 {
+	CET_file = fopen("CET_log", "w");
+	CALCULATE_EXE_TIME
+
 	char *name;
 	unsigned int time;
 
 	sig_preinit(); // Mitigate race conditions
 #ifdef __DJGPP__
-	if (--argc <= 0) return 1;
+	if (--argc <= 0) { CET_BEFORE_RETURN return 1;
+	}
 	if ((name = strrchr(argv[0], '/')))
 		strcpy(name + 1, argv[1]);
 	name = argv[1];
@@ -1561,105 +1676,105 @@ int main(int argc, char **argv)
 
 	if (!strcmp(name, "unshadow")) {
 		CPU_detect_or_fallback(argv, 0);
-		return unshadow(argc, argv);
+		CET_BEFORE_RETURN return unshadow(argc, argv);
 	}
 
 	if (!strcmp(name, "unafs")) {
 		CPU_detect_or_fallback(argv, 0);
-		return unafs(argc, argv);
+		CET_BEFORE_RETURN return unafs(argc, argv);
 	}
 
 	if (!strcmp(name, "undrop")) {
 		CPU_detect_or_fallback(argv, 0);
-		return undrop(argc, argv);
+		CET_BEFORE_RETURN return undrop(argc, argv);
 	}
 
 	if (!strcmp(name, "unique")) {
 		CPU_detect_or_fallback(argv, 0);
-		return unique(argc, argv);
+		CET_BEFORE_RETURN return unique(argc, argv);
 	}
 
 	if (!strcmp(name, "ssh2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return ssh2john(argc, argv);
+		CET_BEFORE_RETURN return ssh2john(argc, argv);
 	}
 
 	if (!strcmp(name, "putty2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return putty2john(argc, argv);
+		CET_BEFORE_RETURN return putty2john(argc, argv);
 	}
 
 	if (!strcmp(name, "pfx2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return pfx2john(argc, argv);
+		CET_BEFORE_RETURN return pfx2john(argc, argv);
 	}
 
 	if (!strcmp(name, "keychain2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return keychain2john(argc, argv);
+		CET_BEFORE_RETURN return keychain2john(argc, argv);
 	}
 
 	if (!strcmp(name, "kwallet2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return kwallet2john(argc, argv);
+		CET_BEFORE_RETURN return kwallet2john(argc, argv);
 	}
 
 	if (!strcmp(name, "keepass2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return keepass2john(argc, argv);
+		CET_BEFORE_RETURN return keepass2john(argc, argv);
 	}
 
 	if (!strcmp(name, "keyring2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return keyring2john(argc, argv);
+		CET_BEFORE_RETURN return keyring2john(argc, argv);
 	}
 
 	if (!strcmp(name, "rar2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return rar2john(argc, argv);
+		CET_BEFORE_RETURN return rar2john(argc, argv);
 	}
 
 	if (!strcmp(name, "racf2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return racf2john(argc, argv);
+		CET_BEFORE_RETURN return racf2john(argc, argv);
 	}
 
 	if (!strcmp(name, "pwsafe2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return pwsafe2john(argc, argv);
+		CET_BEFORE_RETURN return pwsafe2john(argc, argv);
 	}
 
 	if (!strcmp(name, "keystore2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return keystore2john(argc, argv);
+		CET_BEFORE_RETURN return keystore2john(argc, argv);
 	}
 
 	if (!strcmp(name, "truecrypt_volume2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return truecrypt_volume2john(argc, argv);
+		CET_BEFORE_RETURN return truecrypt_volume2john(argc, argv);
 	}
 	if (!strcmp(name, "gpg2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return gpg2john(argc, argv);
+		CET_BEFORE_RETURN return gpg2john(argc, argv);
 	}
 #if !defined (_MSC_VER) && !defined (__MINGW32__)
 	if (!strcmp(name, "dmg2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return dmg2john(argc, argv);
+		CET_BEFORE_RETURN return dmg2john(argc, argv);
 	}
 #endif
 
 	if (!strcmp(name, "zip2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return zip2john(argc, argv);
+		CET_BEFORE_RETURN return zip2john(argc, argv);
 	}
 	if (!strcmp(name, "hccap2john")) {
 		CPU_detect_or_fallback(argv, 0);
-		return hccap2john(argc, argv);
+		CET_BEFORE_RETURN return hccap2john(argc, argv);
 	}
 	if (!strcmp(name, "base64conv")) {
 		CPU_detect_or_fallback(argv, 0);
-		return base64conv(argc, argv);
+		CET_BEFORE_RETURN return base64conv(argc, argv);
 	}
 
 #if HAVE_MPI
@@ -1672,6 +1787,7 @@ int main(int argc, char **argv)
 		error();
 	}
 #endif
+
 	john_init(name, argc, argv);
 
 	/* Placed here to disregard load time. */
@@ -1690,5 +1806,5 @@ int main(int argc, char **argv)
 
 	MEMDBG_PROGRAM_EXIT_CHECKS(stderr);
 
-	return exit_status;
+	CET_BEFORE_RETURN return exit_status;
 }
diff --git a/src/loader.c b/src/loader.c
index a6bab69..43b6627 100644
--- a/src/loader.c
+++ b/src/loader.c
@@ -46,6 +46,8 @@
 #include "logger.h" /* Beware: log_init() happens after most functions here */
 #include "memdbg.h"
 
+#include "calculate_exe_time.h"
+
 #ifdef HAVE_CRYPT
 extern struct fmt_main fmt_crypt;
 #endif
@@ -73,14 +75,18 @@ static int pristine_gecos;
 /* There should be legislation against adding a BOM to UTF-8 */
 static char *skip_bom(char *string)
 {
+	CALCULATE_EXE_TIME
+
 	if (!memcmp(string, "\xEF\xBB\xBF", 3))
 		string += 3;
-	return string;
+	CET_BEFORE_RETURN return string;
 }
 
 static void read_file(struct db_main *db, char *name, int flags,
 	void (*process_line)(struct db_main *db, char *line))
 {
+	CALCULATE_EXE_TIME
+
 	struct stat file_stat;
 	FILE *file;
 	char line_buf[LINE_BUFFER_SIZE], *line;
@@ -92,14 +98,20 @@ static void read_file(struct db_main *db, char *name, int flags,
 	if (flags & RF_ALLOW_DIR) {
 		if (stat(name, &file_stat)) {
 			if (flags & RF_ALLOW_MISSING)
-				if (errno == ENOENT) return;
+				if (errno == ENOENT) { 
+					CET_BEFORE_RETURN return;
+				}
 			pexit("stat: %s", path_expand(name));
 		} else
-			if (S_ISDIR(file_stat.st_mode)) return;
+			if (S_ISDIR(file_stat.st_mode)) { 
+				CET_BEFORE_RETURN return;
+			}
 	}
 
 	if (!(file = fopen(path_expand(name), "r"))) {
-		if ((flags & RF_ALLOW_MISSING) && errno == ENOENT) return;
+		if ((flags & RF_ALLOW_MISSING) && errno == ENOENT) { 
+			CET_BEFORE_RETURN return;
+		}
 		pexit("fopen: %s", path_expand(name));
 	}
 
@@ -141,10 +153,14 @@ static void read_file(struct db_main *db, char *name, int flags,
 	if (ferror(file)) pexit("fgets");
 
 	if (fclose(file)) pexit("fclose");
+
+	CET_BEFORE_RETURN
 }
 
 void ldr_init_database(struct db_main *db, struct db_options *options)
 {
+	CALCULATE_EXE_TIME
+
 	db->loaded = 0;
 
 	db->options = mem_alloc_copy(options,
@@ -180,6 +196,8 @@ void ldr_init_database(struct db_main *db, struct db_options *options)
 	db->salt_count = db->password_count = db->guess_count = 0;
 
 	db->format = NULL;
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -191,6 +209,8 @@ void ldr_init_database(struct db_main *db, struct db_options *options)
  */
 static void ldr_init_password_hash(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	int (*func)(void *binary);
 	int size = PASSWORD_HASH_SIZE_FOR_LDR;
 
@@ -208,14 +228,20 @@ static void ldr_init_password_hash(struct db_main *db)
 	size = password_hash_sizes[size] * sizeof(struct db_password *);
 	db->password_hash = mem_alloc(size);
 	memset(db->password_hash, 0, size);
+
+	CET_BEFORE_RETURN
 }
 
 static char *ldr_get_field(char **ptr, char field_sep_char)
 {
+	CALCULATE_EXE_TIME
+
 	static char *last;
 	char *res, *pos;
 
-	if (!*ptr) return last;
+	if (!*ptr) { 
+		CET_BEFORE_RETURN return last;
+	}
 
 	if ((pos = strchr(res = *ptr, field_sep_char))) {
 		*pos++ = 0; *ptr = pos;
@@ -228,47 +254,53 @@ static char *ldr_get_field(char **ptr, char field_sep_char)
 		*ptr = NULL;
 	}
 
-	return res;
+	CET_BEFORE_RETURN return res;
 }
 
 static int ldr_check_list(struct list_main *list, char *s1, char *s2)
 {
+	CALCULATE_EXE_TIME
+
 	struct list_entry *current;
 	char *data;
 
-	if (!(current = list->head)) return 0;
+	if (!(current = list->head)) CET_BEFORE_RETURN return 0;
 
 	if (*current->data == '-') {
 		data = current->data + 1;
 		do {
-			if (!strcmp(s1, data) || !strcmp(s2, data)) return 1;
+			if (!strcmp(s1, data) || !strcmp(s2, data)) CET_BEFORE_RETURN return 1;
 			if ((current = current->next)) data = current->data;
 		} while (current);
 	} else {
 		do {
 			data = current->data;
-			if (!strcmp(s1, data) || !strcmp(s2, data)) return 0;
+			if (!strcmp(s1, data) || !strcmp(s2, data)) CET_BEFORE_RETURN return 0;
 		} while ((current = current->next));
-		return 1;
+		CET_BEFORE_RETURN return 1;
 	}
 
-	return 0;
+	CET_BEFORE_RETURN return 0;
 }
 
 static int ldr_check_shells(struct list_main *list, char *shell)
 {
+	CALCULATE_EXE_TIME
+
 	char *name;
 
 	if (list->head) {
 		if ((name = strrchr(shell, '/'))) name++; else name = shell;
-		return ldr_check_list(list, shell, name);
+		CET_BEFORE_RETURN return ldr_check_list(list, shell, name);
 	}
 
-	return 0;
+	CET_BEFORE_RETURN return 0;
 }
 
 static void ldr_set_encoding(struct fmt_main *format)
 {
+	CALCULATE_EXE_TIME
+
 	if ((!pers_opts.target_enc || pers_opts.default_target_enc) &&
 	    !pers_opts.internal_enc) {
 		if (!strcasecmp(format->params.label, "LM") ||
@@ -296,7 +328,7 @@ static void ldr_set_encoding(struct fmt_main *format)
 
 	if ((options.flags & FLG_SHOW_CHK) || options.loader.showuncracked) {
 		initUnicode(UNICODE_UNICODE);
-		return;
+		CET_BEFORE_RETURN return;
 	}
 
 	/* john.conf alternative for --internal-encoding */
@@ -322,6 +354,8 @@ static void ldr_set_encoding(struct fmt_main *format)
 	}
 
 	initUnicode(UNICODE_UNICODE);
+
+	CET_BEFORE_RETURN
 }
 
 static int ldr_split_line(char **login, char **ciphertext,
@@ -329,6 +363,8 @@ static int ldr_split_line(char **login, char **ciphertext,
 	char *source, struct fmt_main **format,
 	struct db_options *db_opts, char *line)
 {
+	CALCULATE_EXE_TIME
+
 	struct fmt_main *alt;
 	char *fields[10], *gid, *shell;
 	int i, retval;
@@ -339,8 +375,9 @@ static int ldr_split_line(char **login, char **ciphertext,
 /* Check for NIS stuff */
 	if ((!strcmp(*login, "+") || !strncmp(*login, "+@", 2)) &&
 	    strlen(*ciphertext) < 10 && strncmp(*ciphertext, "$dummy$", 7)
-	    && strncmp(*ciphertext, "$0$", 3))
-		return 0;
+	    && strncmp(*ciphertext, "$0$", 3)) {
+		CET_BEFORE_RETURN return 0;
+	}
 
 	if (!**ciphertext && !line) {
 /* Possible hash on a line on its own (no colons) */
@@ -363,8 +400,9 @@ static int ldr_split_line(char **login, char **ciphertext,
 				(*ciphertext)--;
 			if (p - *ciphertext == 12 && *ciphertext - *login == 1)
 				(*ciphertext)--;
-			if (p - *ciphertext < 13)
-				return 0;
+			if (p - *ciphertext < 13) {
+				CET_BEFORE_RETURN return 0;
+			}
 		}
 		*p = 0;
 		fields[0] = *login = no_username;
@@ -442,9 +480,15 @@ static int ldr_split_line(char **login, char **ciphertext,
 		shell = fields[9];
 	}
 
-	if (ldr_check_list(db_opts->users, *login, *uid)) return 0;
-	if (ldr_check_list(db_opts->groups, gid, gid)) return 0;
-	if (ldr_check_shells(db_opts->shells, shell)) return 0;
+	if (ldr_check_list(db_opts->users, *login, *uid)) { 
+		CET_BEFORE_RETURN return 0;
+	}
+	if (ldr_check_list(db_opts->groups, gid, gid)) {
+		CET_BEFORE_RETURN return 0;
+	}
+	if (ldr_check_shells(db_opts->shells, shell)) { 
+		CET_BEFORE_RETURN return 0;
+	}
 
 	if (*format) {
 		char *prepared;
@@ -458,7 +502,7 @@ static int ldr_split_line(char **login, char **ciphertext,
 
 		if (valid) {
 			*ciphertext = prepared;
-			return valid;
+			CET_BEFORE_RETURN return valid;
 		}
 
 		ldr_set_encoding(*format);
@@ -505,7 +549,7 @@ static int ldr_split_line(char **login, char **ciphertext,
 			}
 		} while ((alt = alt->next));
 
-		return 0;
+		CET_BEFORE_RETURN return 0;
 	}
 
 	retval = -1;
@@ -580,21 +624,25 @@ static int ldr_split_line(char **login, char **ciphertext,
 #endif
 	} while ((alt = alt->next));
 
-	return retval;
+	CET_BEFORE_RETURN return retval;
 }
 
 static char* ldr_conv(char *word)
 {
+	CALCULATE_EXE_TIME
+
 	if (pers_opts.input_enc == UTF_8 && pers_opts.target_enc != UTF_8) {
 		static char u8[PLAINTEXT_BUFFER_SIZE + 1];
 
 		word = utf8_to_cp_r(word, u8, PLAINTEXT_BUFFER_SIZE);
 	}
-	return word;
+	CET_BEFORE_RETURN return word;
 }
 
 static void ldr_split_string(struct list_main *dst, char *src)
 {
+	CALCULATE_EXE_TIME
+
 	char *word, *pos;
 	char c;
 
@@ -611,10 +659,14 @@ static void ldr_split_string(struct list_main *dst, char *src)
 		list_add_unique(dst, word);
 		*pos++ = c;
 	} while (c && dst->count < LDR_WORDS_MAX);
+
+	CET_BEFORE_RETURN
 }
 
 static struct list_main *ldr_init_words(char *login, char *gecos, char *home)
 {
+	CALCULATE_EXE_TIME
+
 	struct list_main *words;
 	char *pos;
 
@@ -631,11 +683,13 @@ static struct list_main *ldr_init_words(char *login, char *gecos, char *home)
 	if ((pos = strrchr(home, '/')) && pos[1])
 		list_add_unique(words, ldr_conv(&pos[1]));
 
-	return words;
+	CET_BEFORE_RETURN return words;
 }
 
 static void ldr_load_pw_line(struct db_main *db, char *line)
 {
+	CALCULATE_EXE_TIME
+
 	static int skip_dupe_checking = 0;
 	struct fmt_main *format;
 	int index, count;
@@ -653,7 +707,9 @@ static void ldr_load_pw_line(struct db_main *db, char *line)
 
 	count = ldr_split_line(&login, &ciphertext, &gecos, &home, &uid,
 		NULL, &db->format, db->options, line);
-	if (count <= 0) return;
+	if (count <= 0) {
+		CET_BEFORE_RETURN return;
+	}
 	if (count >= 2) db->options->flags |= DB_SPLIT;
 
 	format = db->format;
@@ -842,18 +898,25 @@ static void ldr_load_pw_line(struct db_main *db, char *line)
 			}
 		}
 	}
+	CET_BEFORE_RETURN
 }
 
 void ldr_load_pw_file(struct db_main *db, char *name)
 {
+	CALCULATE_EXE_TIME
+
 	pristine_gecos = cfg_get_bool(SECTION_OPTIONS, NULL,
 	        "PristineGecos", 0);
 
 	read_file(db, name, RF_ALLOW_DIR, ldr_load_pw_line);
+
+	CET_BEFORE_RETURN
 }
 
 static void ldr_load_pot_line(struct db_main *db, char *line)
 {
+	CALCULATE_EXE_TIME
+
 	struct fmt_main *format = db->format;
 	char *ciphertext;
 	void *binary;
@@ -861,7 +924,7 @@ static void ldr_load_pot_line(struct db_main *db, char *line)
 	struct db_password *current;
 
 	ciphertext = ldr_get_field(&line, db->options->field_sep_char);
-	if (format->methods.valid(ciphertext, format) != 1) return;
+	if (format->methods.valid(ciphertext, format) != 1) CET_BEFORE_RETURN return;
 	ciphertext = format->methods.split(ciphertext, 0, format);
 	binary = format->methods.binary(ciphertext);
 	hash = db->password_hash_func(binary);
@@ -880,10 +943,13 @@ static void ldr_load_pot_line(struct db_main *db, char *line)
 			continue;
 		current->binary = NULL; /* mark for removal */
 	} while ((current = current->next_hash));
+	CET_BEFORE_RETURN
 }
 
 void ldr_load_pot_file(struct db_main *db, char *name)
 {
+	CALCULATE_EXE_TIME
+
 	if (db->format && !(db->format->params.flags & FMT_NOT_EXACT)) {
 #ifdef HAVE_CRYPT
 		ldr_in_pot = 1;
@@ -893,6 +959,8 @@ void ldr_load_pot_file(struct db_main *db, char *name)
 		ldr_in_pot = 0;
 #endif
 	}
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -906,6 +974,8 @@ void ldr_load_pot_file(struct db_main *db, char *name)
  */
 static void ldr_init_salts(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt **tail, *current;
 	int hash, ctr = 0;
 
@@ -922,6 +992,8 @@ static void ldr_init_salts(struct db_main *db)
 			printf("salt hash %08x, %d salts\n", hash, ctr);
 #endif
 	}
+
+	CET_BEFORE_RETURN
 }
 
 /* #define DEBUG_SALT_SORT */
@@ -929,9 +1001,11 @@ static void ldr_init_salts(struct db_main *db)
 /* Default: Most used salts first */
 static int salt_compare_num(int a, int b)
 {
-	if (a > b) return -1;
-	if (a < b) return 1;
-	return 0;
+	CALCULATE_EXE_TIME
+
+	if (a > b) CET_BEFORE_RETURN return -1;
+	if (a < b) CET_BEFORE_RETURN return 1;
+	CET_BEFORE_RETURN return 0;
 }
 
 /*
@@ -972,17 +1046,21 @@ static int (*fmt_salt_compare)(const void *x, const void *y);
  * is needed to partition sort the data.
  */
 static int ldr_salt_cmp(const void *x, const void *y) {
+	CALCULATE_EXE_TIME
+
 	salt_cmp_t *X = (salt_cmp_t *)x;
 	salt_cmp_t *Y = (salt_cmp_t *)y;
 	int cmp = fmt_salt_compare(X->p->salt, Y->p->salt);
-	return cmp;
+	CET_BEFORE_RETURN return cmp;
 }
 
 static int ldr_salt_cmp_num(const void *x, const void *y) {
+	CALCULATE_EXE_TIME
+
 	salt_cmp_t *X = (salt_cmp_t *)x;
 	salt_cmp_t *Y = (salt_cmp_t *)y;
 	int cmp = salt_compare_num(X->p->count, Y->p->count);
-	return cmp;
+	CET_BEFORE_RETURN return cmp;
 }
 
 /*
@@ -1009,6 +1087,8 @@ static int ldr_salt_cmp_num(const void *x, const void *y) {
  */
 static void ldr_sort_salts(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	int i;
 	struct db_salt *s;
 #ifndef DEBUG_SALT_SORT
@@ -1017,7 +1097,7 @@ static void ldr_sort_salts(struct db_main *db)
 	salt_cmp_t ar[100];  /* array is easier to debug in VC */
 #endif
 	if (db->salt_count < 2)
-		return;
+		CET_BEFORE_RETURN return;
 
 	log_event("Sorting salts, for performance");
 
@@ -1074,6 +1154,8 @@ static void ldr_sort_salts(struct db_main *db)
 	 */
 	s = db->salts;
 #endif
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -1081,6 +1163,8 @@ static void ldr_sort_salts(struct db_main *db)
  */
 static void ldr_show_left(struct db_main *db, struct db_password *pw)
 {
+	CALCULATE_EXE_TIME
+
 	char uid_sep[2] = { 0 };
 	char *uid_out = "";
 	char *pw_source = db->format->methods.source(pw->source, pw->binary);
@@ -1104,6 +1188,8 @@ static void ldr_show_left(struct db_main *db, struct db_password *pw)
 	} else
 		printf("%s%c%s%s%s\n", pw->login, db->options->field_sep_char,
 		       pw_source, uid_sep, uid_out);
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -1112,6 +1198,8 @@ static void ldr_show_left(struct db_main *db, struct db_password *pw)
  */
 static void ldr_remove_marked(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt *current_salt, *last_salt;
 	struct db_password *current_pw, *last_pw;
 
@@ -1146,6 +1234,8 @@ static void ldr_remove_marked(struct db_main *db)
 		} else
 			last_salt = current_salt;
 	} while ((current_salt = current_salt->next));
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -1153,12 +1243,14 @@ static void ldr_remove_marked(struct db_main *db)
  */
 static void ldr_filter_salts(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt *current, *last;
 	int min = db->options->min_pps;
 	int max = db->options->max_pps;
 
 	if (!max) {
-		if (!min) return;
+		if (!min) CET_BEFORE_RETURN return;
 		max = ~(unsigned int)0 >> 1;
 	}
 
@@ -1177,6 +1269,8 @@ static void ldr_filter_salts(struct db_main *db)
 		} else
 			last = current;
 	} while ((current = current->next));
+
+	CET_BEFORE_RETURN
 }
 
 #if FMT_MAIN_VERSION > 11
@@ -1186,13 +1280,16 @@ static void ldr_filter_salts(struct db_main *db)
  */
 static int ldr_cost_ok(struct db_salt *salt, unsigned int *min_cost, unsigned int *max_cost)
 {
+	CALCULATE_EXE_TIME
+
 	int i;
 
 	for (i = 0; i < FMT_TUNABLE_COSTS; i++) {
-		if (salt->cost[i] < min_cost[i] || salt->cost[i] > max_cost[i])
-			return 0;
+		if (salt->cost[i] < min_cost[i] || salt->cost[i] > max_cost[i]) {
+			CET_BEFORE_RETURN return 0;
+		}
 	}
-	return 1;
+	CET_BEFORE_RETURN return 1;
 }
 
 
@@ -1201,6 +1298,8 @@ static int ldr_cost_ok(struct db_salt *salt, unsigned int *min_cost, unsigned in
  */
 static void ldr_filter_costs(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt *current, *last;
 
 	last = NULL;
@@ -1218,6 +1317,8 @@ static void ldr_filter_costs(struct db_main *db)
 		} else
 			last = current;
 	} while ((current = current->next));
+
+	CET_BEFORE_RETURN
 }
 #endif
 
@@ -1227,6 +1328,8 @@ static void ldr_filter_costs(struct db_main *db)
  */
 static void ldr_init_hash_for_salt(struct db_main *db, struct db_salt *salt)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_password *current;
 	int (*hash_func)(void *binary);
 	int bitmap_size, hash_size;
@@ -1240,7 +1343,7 @@ static void ldr_init_hash_for_salt(struct db_main *db, struct db_salt *salt)
 			salt->count++;
 		} while ((current = current->next));
 
-		return;
+		CET_BEFORE_RETURN return;
 	}
 
 	bitmap_size = password_hash_sizes[salt->hash_size];
@@ -1277,6 +1380,8 @@ static void ldr_init_hash_for_salt(struct db_main *db, struct db_salt *salt)
 			current->next_hash = current->next;
 		salt->count++;
 	} while ((current = current->next));
+
+	CET_BEFORE_RETURN
 }
 
 /*
@@ -1285,6 +1390,8 @@ static void ldr_init_hash_for_salt(struct db_main *db, struct db_salt *salt)
  */
 static void ldr_init_hash(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	struct db_salt *current;
 	int threshold, size;
 
@@ -1329,6 +1436,8 @@ static void ldr_init_hash(struct db_main *db)
 			       *(unsigned int*)current->salt, current->count);
 #endif
 	} while ((current = current->next));
+
+	CET_BEFORE_RETURN
 }
 
 #if FMT_MAIN_VERSION > 11
@@ -1337,6 +1446,8 @@ static void ldr_init_hash(struct db_main *db)
  */
 static void ldr_cost_ranges(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	int i;
 	struct db_salt *current;
 
@@ -1354,11 +1465,15 @@ static void ldr_cost_ranges(struct db_main *db)
 				db->max_cost[i] = current->cost[i];
 		}
 	} while ((current = current->next));
+
+	CET_BEFORE_RETURN
 }
 #endif
 
 void ldr_fix_database(struct db_main *db)
 {
+	CALCULATE_EXE_TIME
+
 	int total = db->password_count;
 
 	ldr_init_salts(db);
@@ -1390,10 +1505,14 @@ void ldr_fix_database(struct db_main *db)
 			        total != 1 ? "es" : "", db->password_count);
 		exit(0);
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static int ldr_cracked_hash(char *ciphertext)
 {
+	CALCULATE_EXE_TIME
+
 	unsigned int hash = 0;
 	char *p = ciphertext;
 
@@ -1409,11 +1528,13 @@ static int ldr_cracked_hash(char *ciphertext)
 	hash ^= hash >> CRACKED_HASH_LOG;
 	hash &= CRACKED_HASH_SIZE - 1;
 
-	return hash;
+	CET_BEFORE_RETURN return hash;
 }
 
 static void ldr_show_pot_line(struct db_main *db, char *line)
 {
+	CALCULATE_EXE_TIME
+
 	char *ciphertext, *pos;
 	int hash;
 	struct db_cracked *current, *last;
@@ -1466,7 +1587,7 @@ static void ldr_show_pot_line(struct db_main *db, char *line)
 /* If just one format was forced on the command line, insist on it */
 		if (!fmt_list->next &&
 		    !fmt_list->methods.valid(ciphertext, fmt_list))
-			return;
+			CET_BEFORE_RETURN return;
 
 		pos = line;
 		do {
@@ -1475,7 +1596,7 @@ static void ldr_show_pot_line(struct db_main *db, char *line)
 
 		if (db->options->flags & DB_PLAINTEXTS) {
 			list_add(db->plaintexts, line);
-			return;
+			CET_BEFORE_RETURN return;
 		}
 
 		hash = ldr_cracked_hash(ciphertext);
@@ -1489,10 +1610,14 @@ static void ldr_show_pot_line(struct db_main *db, char *line)
 		current->ciphertext = str_alloc_copy(ciphertext);
 		current->plaintext = str_alloc_copy(line);
 	}
+
+	CET_BEFORE_RETURN
 }
 
 void ldr_show_pot_file(struct db_main *db, char *name)
 {
+	CALCULATE_EXE_TIME
+
 #ifdef HAVE_CRYPT
 	ldr_in_pot = 1;
 #endif
@@ -1500,10 +1625,14 @@ void ldr_show_pot_file(struct db_main *db, char *name)
 #ifdef HAVE_CRYPT
 	ldr_in_pot = 0;
 #endif
+
+	CET_BEFORE_RETURN
 }
 
 static void ldr_show_pw_line(struct db_main *db, char *line)
 {
+	CALCULATE_EXE_TIME
+
 	int show, loop;
 	char source[LINE_BUFFER_SIZE];
 	struct fmt_main *format;
@@ -1521,10 +1650,10 @@ static void ldr_show_pw_line(struct db_main *db, char *line)
 	format = NULL;
 	count = ldr_split_line(&login, &ciphertext, &gecos, &home, &uid,
 		source, &format, db->options, line);
-	if (!count) return;
+	if (!count) CET_BEFORE_RETURN return;
 
 /* If just one format was forced on the command line, insist on it */
-	if (!fmt_list->next && !format) return;
+	if (!fmt_list->next && !format) CET_BEFORE_RETURN return;
 
 	show = !(db->options->flags & DB_PLAINTEXTS);
 
@@ -1637,9 +1766,15 @@ static void ldr_show_pw_line(struct db_main *db, char *line)
 			list_add(db->plaintexts, plain);
 	}
 	if (format || found) db->password_count += count;
+
+	CET_BEFORE_RETURN
 }
 
 void ldr_show_pw_file(struct db_main *db, char *name)
 {
+	CALCULATE_EXE_TIME
+
 	read_file(db, name, RF_ALLOW_DIR, ldr_show_pw_line);
+
+	CET_BEFORE_RETURN
 }
diff --git a/src/wordlist.c b/src/wordlist.c
index 0f21755..c967179 100644
--- a/src/wordlist.c
+++ b/src/wordlist.c
@@ -84,6 +84,8 @@
 #include "mask.h"
 #include "memdbg.h"
 
+#include "calculate_exe_time.h"
+
 #define _STR_VALUE(arg)			#arg
 #define STR_MACRO(n)			_STR_VALUE(n)
 
@@ -110,26 +112,34 @@ static int64_t nWordFileLines;
 
 static void save_state(FILE *file)
 {
+	CALCULATE_EXE_TIME
+
 	fprintf(file, "%d\n" LLd "\n" LLd "\n",
 	        rec_rule, (long long)rec_pos, (long long)rec_line);
+
+	CET_BEFORE_RETURN
 }
 
 static int restore_rule_number(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (rule_ctx)
 	for (rule_number = 0; rule_number < rec_rule; rule_number++)
 	if (!rpp_next(rule_ctx)) {
 		fprintf(stderr, "Restored rule number is out of range - "
 		    "has the configuration file changed?\n");
-		return 1;
+		{ CET_BEFORE_RETURN return 1; }
 	}
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0; }
 }
 
 /* Like fgetl() but for the memory-mapped file. */
 static MAYBE_INLINE char *mgetl(char *res)
 {
+	CALCULATE_EXE_TIME
+
 	char *pos = res;
 
 #if defined(__SSE2__) && !defined(__APPLE__) && !defined(_MSC_VER)
@@ -138,7 +148,7 @@ static MAYBE_INLINE char *mgetl(char *res)
 	__m128i cx16 = _mm_set1_epi8('\n');
 
 	if (map_pos >= map_end)
-		return NULL;
+		{ CET_BEFORE_RETURN return NULL; }
 
 	while (map_pos < map_scan_end && pos < res + LINE_BUFFER_SIZE - 17) {
 		__m128i x = _mm_loadu_si128((__m128i const *)map_pos);
@@ -174,7 +184,7 @@ static MAYBE_INLINE char *mgetl(char *res)
 	unsigned int *d = (unsigned int*)pos;
 
 	if (map_pos >= map_end)
-		return NULL;
+		{ CET_BEFORE_RETURN return NULL;}
 
 	while ((char*)ss < map_scan_end &&
 	       (char*)dd < res + LINE_BUFFER_SIZE - 9 &&
@@ -204,7 +214,7 @@ static MAYBE_INLINE char *mgetl(char *res)
 	unsigned int *d = (unsigned int*)pos;
 
 	if (map_pos >= map_end)
-		return NULL;
+		{ CET_BEFORE_RETURN return NULL;}
 
 	while ((char*)s < map_scan_end &&
 	       (char*)d < res + LINE_BUFFER_SIZE - 5 &&
@@ -222,7 +232,7 @@ static MAYBE_INLINE char *mgetl(char *res)
 #else /* One char at a time */
 
 	if (map_pos >= map_end)
-		return NULL;
+		{ CET_BEFORE_RETURN return NULL;}
 
 	while (map_pos < map_end && pos < res + LINE_BUFFER_SIZE - 1 &&
 	       *map_pos != '\n')
@@ -239,11 +249,13 @@ static MAYBE_INLINE char *mgetl(char *res)
 	if (*--pos == '\r')
 		*pos = 0;
 
-	return res;
+	{ CET_BEFORE_RETURN return res;}
 }
 
 static MAYBE_INLINE int skip_lines(unsigned long n, char *line)
 {
+	CALCULATE_EXE_TIME
+
 	if (n) {
 		line_number += n;
 
@@ -251,15 +263,17 @@ static MAYBE_INLINE int skip_lines(unsigned long n, char *line)
 		do {
 			if (mem_map ? !mgetl(line) :
 			    !fgetl(line, LINE_BUFFER_SIZE, word_file))
-				return 1;
+				{ CET_BEFORE_RETURN return 1;}
 		} while (--n);
 	}
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 static void restore_line_number(void)
 {
+	CALCULATE_EXE_TIME
+
 	char line[LINE_BUFFER_SIZE];
 	if (skip_lines((unsigned long)rec_pos, line)) {
 		if (ferror(word_file))
@@ -267,27 +281,31 @@ static void restore_line_number(void)
 		fprintf(stderr, "fgets: Unexpected EOF\n");
 		error();
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static int restore_state(FILE *file)
 {
+	CALCULATE_EXE_TIME
+
 	long long rule, line, pos;
 
 	if (fscanf(file, LLd"\n"LLd"\n", &rule, &pos) != 2)
-		return 1;
+		{ CET_BEFORE_RETURN return 1;}
 	rec_rule = rule;
 	rec_pos = pos;
 	rec_line = 0;
 	if (rec_version >= 4) {
 		if (fscanf(file, LLd"\n", &line) != 1)
-			return 1;
+			{ CET_BEFORE_RETURN return 1;}
 		rec_line = line;
 	}
 	if (rec_rule < 0 || rec_pos < 0)
-		return 1;
+		{ CET_BEFORE_RETURN return 1;}
 
 	if (restore_rule_number())
-		return 1;
+		{ CET_BEFORE_RETURN return 1;}
 
 	if (word_file == stdin) {
 		restore_line_number();
@@ -302,15 +320,17 @@ static int restore_state(FILE *file)
 		line_number = rec_line;
 	}
 
-	return 0;
+	{ CET_BEFORE_RETURN return 0;}
 }
 
 static int fix_state_delay;
 
 static void fix_state(void)
 {
+	CALCULATE_EXE_TIME
+
 	if (++fix_state_delay < options.max_fix_state_delay)
-		return;
+		{ CET_BEFORE_RETURN return;}
 	fix_state_delay=0;
 
 	rec_rule = rule_number;
@@ -327,20 +347,24 @@ static void fix_state(void)
 #endif
 			pexit(STR_MACRO(jtr_ftell64));
 	}
+
+	CET_BEFORE_RETURN
 }
 
 static double get_progress(void)
 {
+	CALCULATE_EXE_TIME
+
 	int64_t pos, size;
 	unsigned long long mask_mult = mask_tot_cand ? mask_tot_cand : 1;
 
 	emms();
 
 	if (progress)
-		return progress;
+		{ CET_BEFORE_RETURN return progress;}
 
 	if (!word_file || word_file == stdin)
-		return -1;
+		{ CET_BEFORE_RETURN return -1;}
 
 	if (nWordFileLines) {
 		pos = line_number;
@@ -369,8 +393,8 @@ static double get_progress(void)
 	fprintf(stderr, "rule %d/%d mask %llu pos %llu/%llu\n",
 	        rule_number, rule_count, mask_mult, pos, size);
 #endif
-	return (100.0 * ((rule_number * size * mask_mult) + pos * mask_mult) /
-	        (rule_count * size * mask_mult));
+	{ CET_BEFORE_RETURN return (100.0 * ((rule_number * size * mask_mult) + pos * mask_mult) /
+				    (rule_count * size * mask_mult));}
 }
 
 static char *dummy_rules_apply(char *word, char *rule, int split, char *last)
@@ -388,6 +412,8 @@ static char *dummy_rules_apply(char *word, char *rule, int split, char *last)
  */
 static MAYBE_INLINE char *convert(char *line)
 {
+	CALCULATE_EXE_TIME
+
 	char *p;
 
 	if ((options.flags & FLG_LOOPBACK_CHK) &&
@@ -412,7 +438,7 @@ static MAYBE_INLINE char *convert(char *line)
 			*--d = *--s;
 		line = d;
 	}
-	return line;
+	{ CET_BEFORE_RETURN return line;}
 }
 
 static unsigned int hash_log, hash_size, hash_mask;
@@ -422,6 +448,8 @@ static unsigned int hash_log, hash_size, hash_mask;
 /* Copied from unique.c (and modified) */
 static MAYBE_INLINE unsigned int line_hash(char *line)
 {
+	CALCULATE_EXE_TIME
+
 	unsigned int hash, extra;
 	char *p;
 
@@ -453,7 +481,7 @@ static MAYBE_INLINE unsigned int line_hash(char *line)
 
 out:
 	hash &= hash_mask;
-	return hash;
+	{ CET_BEFORE_RETURN return hash;}
 }
 
 typedef struct {
@@ -468,6 +496,8 @@ static struct {
 
 static MAYBE_INLINE int wbuf_unique(char *line)
 {
+	CALCULATE_EXE_TIME
+
 	static unsigned int index = 0;
 	unsigned int current, last, linehash;
 
@@ -481,7 +511,7 @@ static MAYBE_INLINE int wbuf_unique(char *line)
 		current = buffer.data[current].next;
 	}
 	if (current != ENTRY_END_HASH)
-		return 0;
+		{ CET_BEFORE_RETURN return 0;}
 
 	if (last == ENTRY_END_HASH)
 		buffer.hash[linehash] = index;
@@ -492,11 +522,13 @@ static MAYBE_INLINE int wbuf_unique(char *line)
 	buffer.data[index].next = ENTRY_END_HASH;
 	index++;
 
-	return 1;
+	{ CET_BEFORE_RETURN return 1;}
 }
 
 void do_wordlist_crack(struct db_main *db, char *name, int rules)
 {
+	CALCULATE_EXE_TIME
+
 	union {
 		char buffer[2][LINE_BUFFER_SIZE + CACHE_BANK_SHIFT];
 		ARCH_WORD dummy;
@@ -1317,4 +1349,6 @@ next_rule:
 			pexit("fclose");
 		word_file = NULL;
 	}
+
+	CET_BEFORE_RETURN
 }
-- 
1.9.1