31 files changed, 158 insertions, 246 deletions

diff --git a/src/cm/cm.c b/src/cm/cm.c
index cc0f832..c39645f 100644
--- a/src/cm/cm.c
+++ b/src/cm/cm.c
@@ -6,7 +6,7 @@
 #include "io/output.h"
 #include "p1363.h"
 
-int cm_do(config_t *cfg) {
+int cm_do() {
 	debug_log_start("Starting Complex Multiplication method");
 
 	fprintf(err, "This is *NOT IMPLEMENTED* currently.\n");
diff --git a/src/cm/cm.h b/src/cm/cm.h
index d59db87..699fa70 100644
--- a/src/cm/cm.h
+++ b/src/cm/cm.h
@@ -13,9 +13,8 @@
 
 /**
  *
- * @param cfg
  * @return
  */
-int cm_do(config_t *cfg);
+int cm_do();
 
 #endif  // ECGEN_CM_H
diff --git a/src/ecgen.c b/src/ecgen.c
index acec047..713ebbe 100644
--- a/src/ecgen.c
+++ b/src/ecgen.c
@@ -24,6 +24,7 @@
  * @copyright GPL v2.0
  */
 #include <pari/pari.h>
+#include "misc/config.h"
 #include "cm/cm.h"
 #include "exhaustive/exhaustive.h"
 #include "invalid/invalid.h"
@@ -45,17 +46,17 @@ static struct argp argp = {cli_options, cli_parse, cli_args_doc,
 
 bool init(void) {
 	// init PARI, 1GB stack, 1M primes
-	pari_init(cfg.memory, 1000000);
+	pari_init(cfg->memory, 1000000);
 
 	// init PARI PRNG
 	if (!random_init()) return false;
 
 	// init the signal handlers, etc. for timeout handling
-	if (!timeout_init(&cfg)) return false;
+	if (!timeout_init()) return false;
 
 	// set datadir if specified
-	if (cfg.datadir) {
-		default0("datadir", cfg.datadir);
+	if (cfg->datadir) {
+		default0("datadir", cfg->datadir);
 	}
 
 	// init the modular polynomial db from seadata
@@ -69,10 +70,10 @@ bool init(void) {
 	pari_ENDCATCH avma = ltop;
 
 	// open outfile
-	if (!output_init(&cfg)) return false;
+	if (!output_init(cfg)) return false;
 
 	// open infile
-	if (!input_init(&cfg)) return false;
+	if (!input_init(cfg)) return false;
 
 	return true;
 }
@@ -136,20 +137,20 @@ int quit(int status) {
  */
 int main(int argc, char *argv[]) {
 	// Parse cli args
-	memset(&cfg, 0, sizeof(cfg));
-	argp_parse(&argp, argc, argv, 0, 0, &cfg);
+	memset(cfg, 0, sizeof(cfg_s));
+	argp_parse(&argp, argc, argv, 0, 0, cfg);
 
 	if (!init()) {
 		return quit(EXIT_FAILURE);
 	}
 
 	int status;
-	if (cfg.cm) {
-		status = cm_do(&cfg);
-	} else if (cfg.invalid) {
-		status = invalid_do(&cfg);
+	if (cfg->cm) {
+		status = cm_do();
+	} else if (cfg->invalid) {
+		status = invalid_do();
 	} else {
-		status = exhaustive_do(&cfg);
+		status = exhaustive_do();
 	}
 	return quit(status);
 }
diff --git a/src/exhaustive/anomalous.h b/src/exhaustive/anomalous.h
index 886ef62..f03d535 100644
--- a/src/exhaustive/anomalous.h
+++ b/src/exhaustive/anomalous.h
@@ -23,7 +23,6 @@ typedef struct {
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args the index of the discriminant to use, in the disc_table
  * @return state diff
  */
@@ -33,7 +32,6 @@ GENERATOR(anomalous_gen_field);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args the index of the discriminant to use, in the disc_table
  * @return state diff
  */
@@ -43,7 +41,6 @@ GENERATOR(anomalous_gen_equation);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
diff --git a/src/exhaustive/ansi.c b/src/exhaustive/ansi.c
index d18ea02..762ffb7 100644
--- a/src/exhaustive/ansi.c
+++ b/src/exhaustive/ansi.c
@@ -44,7 +44,7 @@ static void seed_hash(seed_t *seed) {
 	bits_sha1(seed->seed, seed->hash20);
 }
 
-static void seed_tsh(seed_t *seed, const config_t *cfg) {
+static void seed_tsh(seed_t *seed) {
 	pari_sp ltop = avma;
 	seed->ansi.t = utoi(cfg->bits);
 	seed->ansi.s =
@@ -57,7 +57,7 @@ GENERATOR(ansi_gen_seed_random) {
 	seed_t *seed = ansi_new();
 	seed->seed = bits_from_i(random_int(160));
 	seed_hash(seed);
-	seed_tsh(seed, cfg);
+	seed_tsh(seed);
 	curve->seed = seed;
 	return 1;
 }
@@ -66,7 +66,7 @@ GENERATOR(ansi_gen_seed_argument) {
 	seed_t *seed = ansi_new();
 	seed->seed = seed_stoi(cfg->seed);
 	seed_hash(seed);
-	seed_tsh(seed, cfg);
+	seed_tsh(seed);
 	curve->seed = seed;
 	return 1;
 }
@@ -85,7 +85,7 @@ GENERATOR(ansi_gen_seed_input) {
 	seed_t *seed = ansi_new();
 	seed->seed = seed_stoi(cstr);
 	seed_hash(seed);
-	seed_tsh(seed, cfg);
+	seed_tsh(seed);
 	curve->seed = seed;
 	return 1;
 }
@@ -183,9 +183,9 @@ static GENERATOR(ansi_gen_equation_f2m) {
 GENERATOR(ansi_gen_equation) {
 	switch (cfg->field) {
 		case FIELD_PRIME:
-			return ansi_gen_equation_fp(curve, cfg, args, state);
+			return ansi_gen_equation_fp(curve, args, state);
 		case FIELD_BINARY:
-			return ansi_gen_equation_f2m(curve, cfg, args, state);
+			return ansi_gen_equation_f2m(curve, args, state);
 		default:
 			pari_err_BUG("Field not prime or binary?");
 			return INT_MIN; /* NOT REACHABLE */
diff --git a/src/exhaustive/ansi.h b/src/exhaustive/ansi.h
index 7c6e7b7..57f3eaf 100644
--- a/src/exhaustive/ansi.h
+++ b/src/exhaustive/ansi.h
@@ -15,7 +15,6 @@ bool ansi_seed_valid(const char *hex_str);
 /**
  * @brief
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -24,7 +23,6 @@ GENERATOR(ansi_gen_seed_random);
 /**
  * @brief
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -33,7 +31,6 @@ GENERATOR(ansi_gen_seed_argument);
 /**
  * @brief
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -42,7 +39,6 @@ GENERATOR(ansi_gen_seed_input);
 /**
  * @brief
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
diff --git a/src/exhaustive/exhaustive.c b/src/exhaustive/exhaustive.c
index dd10255..81ca834 100644
--- a/src/exhaustive/exhaustive.c
+++ b/src/exhaustive/exhaustive.c
@@ -30,7 +30,7 @@ void exhaustive_clear(exhaustive_t *setup) {
 	}
 }
 
-static void exhaustive_ginit(gen_f *generators, const config_t *cfg) {
+static void exhaustive_ginit(gen_f *generators) {
 	if (cfg->seed_algo) {
 		switch (cfg->seed_algo) {
 			case SEED_ANSI: {
@@ -142,12 +142,12 @@ static void exhaustive_ginit(gen_f *generators, const config_t *cfg) {
 	}
 }
 
-static void exhaustive_cinit(check_t **validators, const config_t *cfg) {
+static void exhaustive_cinit(check_t **validators) {
 	check_t *curve_check = check_new(curve_check_nonzero, NULL);
 	validators[OFFSET_CURVE] = curve_check;
 }
 
-static void exhaustive_ainit(arg_t **argss, const config_t *cfg) {
+static void exhaustive_ainit(arg_t **argss) {
 	if (cfg->anomalous) {
 		arg_t *field_arg = arg_new();
 		arg_t *eq_arg = arg_new();
@@ -179,7 +179,7 @@ static void exhaustive_ainit(arg_t **argss, const config_t *cfg) {
 	}
 }
 
-void exhaustive_uinit(unroll_f *unrolls, const config_t *cfg) {
+void exhaustive_uinit(unroll_f *unrolls) {
 	if (cfg->seed_algo) {
 		unrolls[OFFSET_SEED] = &seed_unroll;
 	} else {
@@ -194,9 +194,8 @@ void exhaustive_uinit(unroll_f *unrolls, const config_t *cfg) {
 	unrolls[OFFSET_POINTS] = &points_unroll;
 }
 
-int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
-                         const exhaustive_t *setup, offset_e start_offset,
-                         offset_e end_offset, int retry) {
+int exhaustive_gen_retry(curve_t *curve, const exhaustive_t *setup,
+						 offset_e start_offset, offset_e end_offset, int retry) {
 	if (start_offset == end_offset) {
 		return 2;
 	}
@@ -225,7 +224,7 @@ int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
 			timeout = true;
 		}
 		else {
-			diff = generators[state](curve, cfg, arg, (offset_e)state);
+			diff = generators[state](curve, arg, (offset_e)state);
 		}
 		timeout_stop();
 		int new_state = state + diff;
@@ -235,7 +234,7 @@ int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
 			check_t *validator = validators[state];
 			for (size_t i = 0; i < validator->nchecks; ++i) {
 				int new_diff =
-				    validator->checks[i](curve, cfg, arg, (offset_e)state);
+				    validator->checks[i](curve, arg, (offset_e)state);
 				if (new_diff <= 0) {
 					diff = new_diff;
 					break;
@@ -261,8 +260,7 @@ int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
 			// unroll
 			for (int i = state; i > new_state;) {
 				if (unrolls && unrolls[i]) {
-					i += unrolls[i](curve, cfg, stack_tops[i],
-					                stack_tops[i - 1]);
+					i += unrolls[i](curve, stack_tops[i], stack_tops[i - 1]);
 				} else {
 					--i;
 				}
@@ -292,17 +290,16 @@ int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
 	return 1;
 }
 
-int exhaustive_gen(curve_t *curve, const config_t *cfg,
-                   const exhaustive_t *setup, offset_e start_offset,
-                   offset_e end_offset) {
-	return exhaustive_gen_retry(curve, cfg, setup, start_offset, end_offset, 0);
+int exhaustive_gen(curve_t *curve, const exhaustive_t *setup,
+				   offset_e start_offset, offset_e end_offset) {
+	return exhaustive_gen_retry(curve, setup, start_offset, end_offset, 0);
 }
 
-static void exhaustive_init(exhaustive_t *setup, const config_t *cfg) {
-	exhaustive_ginit(setup->generators, cfg);
-	exhaustive_cinit(setup->validators, cfg);
-	exhaustive_ainit(setup->argss, cfg);
-	exhaustive_uinit(setup->unrolls, cfg);
+static void exhaustive_init(exhaustive_t *setup) {
+	exhaustive_ginit(setup->generators);
+	exhaustive_cinit(setup->validators);
+	exhaustive_ainit(setup->argss);
+	exhaustive_uinit(setup->unrolls);
 	anomalous_init();
 }
 
@@ -312,7 +309,7 @@ static void exhaustive_quit(exhaustive_t *setup) {
 	exhaustive_clear(setup);
 }
 
-int exhaustive_do(config_t *cfg) {
+int exhaustive_do() {
 	debug_log_start("Starting Exhaustive method");
 
 	gen_f generators[OFFSET_END] = {NULL};
@@ -324,25 +321,25 @@ int exhaustive_do(config_t *cfg) {
 	                      .validators = validators,
 	                      .argss = argss,
 	                      .unrolls = unrolls};
-	exhaustive_init(&setup, cfg);
+	exhaustive_init(&setup);
 
-	output_o_begin(cfg);
+	output_o_begin();
 	for (unsigned long i = 0; i < cfg->count; ++i) {
 		debug_log_start("Generating new curve");
 		curve_t *curve = curve_new();
-		if (!exhaustive_gen(curve, cfg, &setup, OFFSET_SEED, OFFSET_END)) {
+		if (!exhaustive_gen(curve, &setup, OFFSET_SEED, OFFSET_END)) {
 			curve_free(&curve);
 			return EXIT_FAILURE;
 		}
 		debug_log_end("Generated new curve");
 
-		output_o(curve, cfg);
+		output_o(curve);
 		if (i != cfg->count - 1) {
-			output_o_separator(cfg);
+			output_o_separator();
 		}
 		curve_free(&curve);
 	}
-	output_o_end(cfg);
+	output_o_end();
 
 	exhaustive_quit(&setup);
 	debug_log_end("Finished Exhaustive method");
diff --git a/src/exhaustive/exhaustive.h b/src/exhaustive/exhaustive.h
index 8d11da2..d212e64 100644
--- a/src/exhaustive/exhaustive.h
+++ b/src/exhaustive/exhaustive.h
@@ -28,43 +28,36 @@ void exhaustive_clear(exhaustive_t *setup);
 
 /**
  *
- * @param unrolls
- * @param cfg
  */
-void exhaustive_uinit(unroll_f *unrolls, const config_t *cfg);
+void exhaustive_uinit(unroll_f *unrolls);
 
 /**
  *
  * @param curve
- * @param cfg
  * @param setup
  * @param start_offset
  * @param end_offset
  * @param retry
  * @return
  */
-int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
-                         const exhaustive_t *setup, offset_e start_offset,
-                         offset_e end_offset, int retry);
+int exhaustive_gen_retry(curve_t *curve, const exhaustive_t *setup,
+						 offset_e start_offset, offset_e end_offset, int retry);
 
 /**
  *
  * @param curve
- * @param config
  * @param setup
  * @param start_offset
  * @param end_offset
  * @return
  */
-int exhaustive_gen(curve_t *curve, const config_t *cfg,
-                   const exhaustive_t *setup, offset_e start_offset,
-                   offset_e end_offset);
+int exhaustive_gen(curve_t *curve, const exhaustive_t *setup,
+				   offset_e start_offset, offset_e end_offset);
 
 /**
  *
- * @param cfg
  * @return
  */
-int exhaustive_do(config_t *cfg);
+int exhaustive_do();
 
 #endif  // ECGEN_EXHAUSTIVE_H
diff --git a/src/gen/curve.h b/src/gen/curve.h
index 1bff19a..64a51b2 100644
--- a/src/gen/curve.h
+++ b/src/gen/curve.h
@@ -17,7 +17,6 @@
  * Always succeeds.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -28,7 +27,6 @@ GENERATOR(curve_gen_any);
  * Checks that the curve has non-zero discriminant.
  *
  * @param curve
- * @param cfg
  * @param args
  * @return
  */
@@ -37,7 +35,6 @@ CHECK(curve_check_nonzero);
 /**
  *
  * @param curve
- * @param cfg
  * @param from
  * @param to
  * @return
diff --git a/src/gen/equation.c b/src/gen/equation.c
index 9d85c13..4f8a36b 100644
--- a/src/gen/equation.c
+++ b/src/gen/equation.c
@@ -36,7 +36,7 @@ GENERATOR(a_gen_once) {
 		return 1;
 	}
 
-	int inp = a_gen_input(curve, cfg, args, state);
+	int inp = a_gen_input(curve, args, state);
 	if (inp > 0) {
 		a = gclone(curve->a);
 		curve_a = curve;
@@ -86,7 +86,7 @@ GENERATOR(b_gen_once) {
 		return 1;
 	}
 
-	int inp = b_gen_input(curve, cfg, args, state);
+	int inp = b_gen_input(curve, args, state);
 	if (inp > 0) {
 		b = gclone(curve->b);
 		curve_b = curve;
diff --git a/src/gen/equation.h b/src/gen/equation.h
index aece5fa..e0906a5 100644
--- a/src/gen/equation.h
+++ b/src/gen/equation.h
@@ -17,7 +17,6 @@
  * Always succeeds.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -28,7 +27,6 @@ GENERATOR(a_gen_random);
  * Creates a parameter by reading from input.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -39,7 +37,6 @@ GENERATOR(a_gen_input);
  * Creates a parameter by reading once from input.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -50,7 +47,6 @@ GENERATOR(a_gen_once);
  * Creates a parameter set to zero.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -61,7 +57,6 @@ GENERATOR(a_gen_zero);
  * Creates a parameter set to one.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -71,7 +66,6 @@ GENERATOR(a_gen_one);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -83,7 +77,6 @@ GENERATOR(a_gen_seed);
  * element from the curve field.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -94,7 +87,6 @@ GENERATOR(b_gen_random);
  * Creates b parameter by reading from input.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -105,7 +97,6 @@ GENERATOR(b_gen_input);
  * Creates b parameter by reading once from input.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -116,7 +107,6 @@ GENERATOR(b_gen_once);
  * Creates b parameter set to zero.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -127,7 +117,6 @@ GENERATOR(b_gen_zero);
  * Creates b parameter set to one.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -137,7 +126,6 @@ GENERATOR(b_gen_one);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
diff --git a/src/gen/field.c b/src/gen/field.c
index 898af9e..020927c 100644
--- a/src/gen/field.c
+++ b/src/gen/field.c
@@ -104,7 +104,7 @@ GENERATOR(field_gen_once) {
 		return 1;
 	}
 
-	int inp = field_gen_input(curve, cfg, args, state);
+	int inp = field_gen_input(curve, args, state);
 	if (inp > 0) {
 		field = gclone(curve->field);
 		curve_field = curve;
diff --git a/src/gen/field.h b/src/gen/field.h
index e02c0b4..50cef8e 100644
--- a/src/gen/field.h
+++ b/src/gen/field.h
@@ -16,7 +16,6 @@
  * Always succeeds.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -29,7 +28,6 @@ GENERATOR(field_gen_random);
  *  - three short exponents of the reduction polynomial in the binary case
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -40,7 +38,6 @@ GENERATOR(field_gen_input);
  * Creates the field by reading it once.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
diff --git a/src/gen/gens.h b/src/gen/gens.h
index c3ae2fc..ace1a88 100644
--- a/src/gen/gens.h
+++ b/src/gen/gens.h
@@ -15,7 +15,6 @@
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -25,7 +24,6 @@ GENERATOR(gens_gen_any);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -35,7 +33,6 @@ GENERATOR(gens_gen_one);
  * UNROLL(unroll_f)
  *
  * @param curve
- * @param cfg
  * @param from
  * @param to
  * @return
diff --git a/src/gen/gp.h b/src/gen/gp.h
index ff91bc5..da2cdc1 100644
--- a/src/gen/gp.h
+++ b/src/gen/gp.h
@@ -13,7 +13,6 @@
 /**
  * @brief
  * @param curve
- * @param cfg
  * @param args
  * @return
  */
@@ -22,7 +21,6 @@ GENERATOR(gp_gen);
 /**
  * @brief
  * @param curve
- * @param cfg
  * @param args
  * @param state
  * @return
diff --git a/src/gen/order.h b/src/gen/order.h
index 14f5a45..da06de5 100644
--- a/src/gen/order.h
+++ b/src/gen/order.h
@@ -15,7 +15,6 @@
  * Reads the curve order from input, does not verify it.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args Current optional generator argument
  * @return state diff
  * @return state diff
@@ -28,7 +27,6 @@ GENERATOR(order_gen_input);
  * Always succeeds.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args Current optional generator argument
  * @return state diff
  */
@@ -39,7 +37,6 @@ GENERATOR(order_gen_any);
  * Calculates the curve order, using the SEA algorithm.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -49,7 +46,6 @@ GENERATOR(order_gen_sea);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args pari_ulong passed to ellsea(curve, smallfact)
  * @return state diff
  */
@@ -62,7 +58,6 @@ GENERATOR(order_gen_smallfact);
  * Succeeds if the curve has a prime order.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
diff --git a/src/gen/point.c b/src/gen/point.c
index 61ca7e1..36717ff 100644
--- a/src/gen/point.c
+++ b/src/gen/point.c
@@ -172,17 +172,17 @@ GENERATOR(points_gen_trial) {
 }
 
 GENERATOR(points_gen_prime) {
-	GEN primes = subgroups_prime(curve, cfg);
+	GEN primes = subgroups_prime(curve);
 	return points_from_orders(curve, primes);
 }
 
 GENERATOR(points_gen_allgroups) {
-	GEN groups = subgroups_all(curve, cfg);
+	GEN groups = subgroups_all(curve);
 	return points_from_orders(curve, groups);
 }
 
 GENERATOR(points_gen_nonprime) {
-	GEN groups = subgroups_nonprime(curve, cfg);
+	GEN groups = subgroups_nonprime(curve);
 	if (!groups) {
 		// No non-prime order points on curve.
 		return 1;
diff --git a/src/gen/point.h b/src/gen/point.h
index dbd25b1..caea625 100644
--- a/src/gen/point.h
+++ b/src/gen/point.h
@@ -110,7 +110,6 @@ void points_free_deep(point_t ***points, size_t npoints);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -120,7 +119,6 @@ GENERATOR(point_gen_random);
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args size_t number of points to generate
  * @return state diff
  */
@@ -134,7 +132,6 @@ GENERATOR(points_gen_random);
  * prime orders specified exist.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args pari_ulong array of primes length nargs
  * @return state diff
  */
@@ -148,7 +145,6 @@ GENERATOR(points_gen_trial);
  *   G has an element of order p.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -160,7 +156,6 @@ GENERATOR(points_gen_prime);
  * Generates points on all subgroups of the curve. Prime and non-prime order.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -172,7 +167,6 @@ GENERATOR(points_gen_allgroups);
  * Generates points on non-prime order of the curve.
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -182,7 +176,6 @@ GENERATOR(points_gen_nonprime);
  * UNROLL(unroll_f)
  *
  * @param curve
- * @param cfg
  * @param from
  * @param to
  * @return
diff --git a/src/invalid/invalid.c b/src/invalid/invalid.c
index 65fc6dc..e908aa4 100644
--- a/src/invalid/invalid.c
+++ b/src/invalid/invalid.c
@@ -16,7 +16,7 @@
 #include "io/output.h"
 #include "util/memory.h"
 
-static void invalid_original_ginit(gen_f *generators, const config_t *cfg) {
+static void invalid_original_ginit(gen_f *generators) {
 	generators[OFFSET_SEED] = &gen_skip;
 	if (cfg->random) {
 		generators[OFFSET_FIELD] = &field_gen_random;
@@ -32,7 +32,7 @@ static void invalid_original_ginit(gen_f *generators, const config_t *cfg) {
 	generators[OFFSET_ORDER] = &order_gen_any;
 }
 
-static void invalid_invalid_ginit(gen_f *generators, const config_t *cfg) {
+static void invalid_invalid_ginit(gen_f *generators) {
 	generators[OFFSET_SEED] = &gen_skip;
 	generators[OFFSET_FIELD] = &gen_skip;
 	generators[OFFSET_A] = &gen_skip;
@@ -47,14 +47,14 @@ static void invalid_invalid_ginit(gen_f *generators, const config_t *cfg) {
 	generators[OFFSET_POINTS] = &points_gen_trial;
 }
 
-static void invalid_cinit(check_t **validators, const config_t *cfg) {
+static void invalid_cinit(check_t **validators) {
 	check_t *curve_check = check_new(curve_check_nonzero, NULL);
 	validators[OFFSET_CURVE] = curve_check;
 }
 
-static void invalid_init(exhaustive_t *setup, const config_t *cfg) {
-	invalid_cinit(setup->validators, cfg);
-	exhaustive_uinit(setup->unrolls, cfg);
+static void invalid_init(exhaustive_t *setup) {
+	invalid_cinit(setup->validators);
+	exhaustive_uinit(setup->unrolls);
 }
 
 static size_t invalid_primes(GEN order, pari_ulong **primes) {
@@ -91,9 +91,9 @@ static size_t invalid_primes(GEN order, pari_ulong **primes) {
 	return nprimes;
 }
 
-static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
-                                    pari_ulong *primes, size_t nprimes,
-                                    curve_t **curves, exhaustive_t *setup) {
+static size_t invalid_curves_single(const curve_t *curve, pari_ulong *primes,
+									size_t nprimes, curve_t **curves,
+									exhaustive_t *setup) {
 	arg_t *invalid_argss[OFFSET_END] = {NULL};
 	exhaustive_t invalid_setup = {.generators = setup->generators,
 	                              .validators = setup->validators,
@@ -109,7 +109,7 @@ static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
 	while (ncurves < nprimes) {
 		pari_sp btop = avma;
 		/* generate a curve with random b */
-		exhaustive_gen(invalid, cfg, setup, OFFSET_B, OFFSET_GENERATORS);
+		exhaustive_gen(invalid, setup, OFFSET_B, OFFSET_GENERATORS);
 
 		/*
 		 * does some small prime from our array divide the curve order?
@@ -127,10 +127,9 @@ static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
 		}
 
 		if (total > 0) {
-			if (!exhaustive_gen_retry(invalid, cfg, setup, OFFSET_GENERATORS,
+			if (!exhaustive_gen_retry(invalid, setup, OFFSET_GENERATORS,
 			                          OFFSET_POINTS, 1)) {
-				curve_unroll(invalid, cfg, avma,
-				             btop);  // necessary to free the ellinit
+				curve_unroll(invalid, avma, btop);  // necessary to free the ellinit
 				avma = btop;
 				continue;
 			}
@@ -157,7 +156,7 @@ static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
 			 * generate prime order points, this is expensive (order needs to be
 			 * factorised, so only do it if we want the curve)
 			 */
-			exhaustive_gen(invalid, cfg, &invalid_setup, OFFSET_POINTS,
+			exhaustive_gen(invalid, &invalid_setup, OFFSET_POINTS,
 			               OFFSET_END);
 
 			size_t count = 0;
@@ -170,9 +169,9 @@ static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
 						// copy if pointer already assigned
 						curves[i] = curve_new_copy(invalid);
 					}
-					output_o(curves[i], cfg);
+					output_o(curves[i]);
 					if (ncurves != nprimes - 1) {
-						output_o_separator(cfg);
+						output_o_separator();
 					}
 					ncurves++;
 					count++;
@@ -200,7 +199,7 @@ static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
 			 * like it never existed, but don't free it yet.
 			 */
 
-			curve_unroll(invalid, cfg, avma, btop);
+			curve_unroll(invalid, avma, btop);
 			avma = btop;
 		}
 	}
@@ -209,9 +208,9 @@ static size_t invalid_curves_single(const curve_t *curve, const config_t *cfg,
 	return ncurves;
 }
 
-static size_t invalid_curves_threaded(const curve_t *curve, const config_t *cfg,
-                                      pari_ulong *primes, size_t nprimes,
-                                      curve_t **curves, exhaustive_t *setup) {
+static size_t invalid_curves_threaded(const curve_t *curve, pari_ulong *primes,
+									  size_t nprimes, curve_t **curves,
+									  exhaustive_t *setup) {
 	pthread_t pthreads[cfg->threads];
 	thread_t threads[cfg->threads];
 	struct pari_thread pari_threads[cfg->threads];
@@ -256,9 +255,9 @@ static size_t invalid_curves_threaded(const curve_t *curve, const config_t *cfg,
 		pthread_cond_wait(&generated_cond, &state_mutex);
 		for (size_t i = 0; i < nprimes; ++i) {
 			if (old_states[i] != states[i] && states[i] == STATE_GENERATED) {
-				output_o(local_curves[i], cfg);
+				output_o(local_curves[i]);
 				if (generated != nprimes) {
-					output_o_separator(cfg);
+					output_o_separator();
 				}
 				old_states[i] = states[i];
 			}
@@ -286,9 +285,9 @@ static size_t invalid_curves_threaded(const curve_t *curve, const config_t *cfg,
 	return generated;
 }
 
-curve_t *invalid_original_curve(exhaustive_t *setup, const config_t *cfg) {
+curve_t *invalid_original_curve(exhaustive_t *setup) {
 	curve_t *curve = curve_new();
-	if (!exhaustive_gen(curve, cfg, setup, OFFSET_FIELD, OFFSET_POINTS)) {
+	if (!exhaustive_gen(curve, setup, OFFSET_FIELD, OFFSET_POINTS)) {
 		exhaustive_clear(setup);
 		curve_free(&curve);
 		exit(EXIT_FAILURE);
@@ -296,7 +295,7 @@ curve_t *invalid_original_curve(exhaustive_t *setup, const config_t *cfg) {
 	return curve;
 }
 
-int invalid_do(config_t *cfg) {
+int invalid_do() {
 	debug_log_start("Starting Invalid curve method");
 
 	gen_f original_gens[OFFSET_END] = {NULL};
@@ -309,22 +308,22 @@ int invalid_do(config_t *cfg) {
 	                               .validators = common_validators,
 	                               .argss = common_argss,
 	                               .unrolls = common_unrolls};
-	invalid_init(&original_setup, cfg);
-	invalid_original_ginit(original_gens, cfg);
+	invalid_init(&original_setup);
+	invalid_original_ginit(original_gens);
 
 	exhaustive_t invalid_setup = {.generators = invalid_gens,
 	                              .validators = common_validators,
 	                              .argss = common_argss,
 	                              .unrolls = common_unrolls};
-	invalid_invalid_ginit(invalid_gens, cfg);
+	invalid_invalid_ginit(invalid_gens);
 
 	debug_log_start("Starting to create curve to invalidate");
-	curve_t *curve = invalid_original_curve(&original_setup, cfg);
+	curve_t *curve = invalid_original_curve(&original_setup);
 	debug_log_end("Finished creating curve to invalidate");
 
-	output_o_begin(cfg);
-	output_o(curve, cfg);
-	output_o_separator(cfg);
+	output_o_begin();
+	output_o(curve);
+	output_o_separator();
 
 	debug_log_start("Starting to generate primes to product over order^2");
 	pari_ulong *primes;
@@ -335,10 +334,10 @@ int invalid_do(config_t *cfg) {
 	debug_log_start("Starting to generate invalid curves");
 	size_t ncurves;
 	if (cfg->threads == 1) {
-		ncurves = invalid_curves_single(curve, cfg, primes, nprimes, curves,
+		ncurves = invalid_curves_single(curve, primes, nprimes, curves,
 		                                &invalid_setup);
 	} else {
-		ncurves = invalid_curves_threaded(curve, cfg, primes, nprimes, curves,
+		ncurves = invalid_curves_threaded(curve, primes, nprimes, curves,
 		                                  &invalid_setup);
 	}
 	debug_log_end("Finished generating invalid curves");
diff --git a/src/invalid/invalid.h b/src/invalid/invalid.h
index a08c5d8..adb29a6 100644
--- a/src/invalid/invalid.h
+++ b/src/invalid/invalid.h
@@ -12,9 +12,8 @@
 
 /**
  *
- * @param cfg
  * @return
  */
-int invalid_do(config_t *cfg);
+int invalid_do();
 
 #endif  // ECGEN_INVALID_H
diff --git a/src/invalid/invalid_thread.c b/src/invalid/invalid_thread.c
index 2e87a3d..8967d31 100644
--- a/src/invalid/invalid_thread.c
+++ b/src/invalid/invalid_thread.c
@@ -23,7 +23,7 @@ void *invalid_thread(void *arg) {
 
 	while (*thread->generated < thread->nprimes) {
 		pari_sp btop = avma;
-		exhaustive_gen(invalid, thread->cfg, thread->setup, OFFSET_B,
+		exhaustive_gen(invalid, thread->setup, OFFSET_B,
 		               OFFSET_GENERATORS);
 		size_t ndivides = 0;
 		for (size_t i = thread->nprimes; i-- > 0;) {
@@ -34,7 +34,7 @@ void *invalid_thread(void *arg) {
 		}
 
 		if (ndivides > 0 &&
-		    exhaustive_gen_retry(invalid, thread->cfg, &invalid_setup,
+		    exhaustive_gen_retry(invalid, &invalid_setup,
 		                         OFFSET_GENERATORS, OFFSET_POINTS, 1)) {
 			pthread_mutex_lock(thread->mutex_state);
 			size_t nfree = 0;
@@ -54,7 +54,7 @@ void *invalid_thread(void *arg) {
 			if (nfree > 0) {
 				arg_t prime_divisors = {primes, nprimes};
 				invalid_argss[OFFSET_POINTS] = &prime_divisors;
-				exhaustive_gen(invalid, thread->cfg, &invalid_setup,
+				exhaustive_gen(invalid, &invalid_setup,
 				               OFFSET_POINTS, OFFSET_END);
 
 				pthread_mutex_lock(thread->mutex_state);
@@ -78,7 +78,7 @@ void *invalid_thread(void *arg) {
 		}
 
 		// We were unsuccessful for some reason, unroll
-		curve_unroll(invalid, thread->cfg, avma, btop);
+		curve_unroll(invalid, avma, btop);
 		avma = btop;
 	}
 	curve_free(&invalid);
diff --git a/src/io/cli.c b/src/io/cli.c
index 0a707de..a538827 100644
--- a/src/io/cli.c
+++ b/src/io/cli.c
@@ -111,8 +111,6 @@ static unsigned long cli_parse_time(const char *str, struct argp_state *state) {
 }
 
 error_t cli_parse(int key, char *arg, struct argp_state *state) {
-	config_t *cfg = state->input;
-
 	switch (key) {
 		case OPT_DATADIR:
 			cfg->datadir = arg;
diff --git a/src/io/input.c b/src/io/input.c
index 8c59209..1ff162c 100644
--- a/src/io/input.c
+++ b/src/io/input.c
@@ -84,7 +84,7 @@ GEN input_string(const char *prompt) {
 	return result;
 }
 
-bool input_init(const config_t *cfg) {
+bool input_init() {
 	if (cfg->input) {
 		in = fopen(cfg->input, "r");
 		delim = ',';
diff --git a/src/io/input.h b/src/io/input.h
index bdc86ec..5d3ec96 100644
--- a/src/io/input.h
+++ b/src/io/input.h
@@ -48,10 +48,9 @@ extern FILE *in;
 
 /**
  * @brief Initialize input based on cfg.
- * @param cfg
  * @return whether the initialization was successful
  */
-bool input_init(const config_t *cfg);
+bool input_init();
 
 /**
  * @brief Deinitialize input.
diff --git a/src/io/output.c b/src/io/output.c
index 07f2cfd..2b6358f 100644
--- a/src/io/output.c
+++ b/src/io/output.c
@@ -19,7 +19,7 @@ char *output_malloc(const char *what) {
 	return s;
 }
 
-char *output_scsv(curve_t *curve, const config_t *cfg) {
+char *output_scsv(curve_t *curve) {
 	pari_sp ltop = avma;
 	char *params[OFFSET_END] = {NULL};
 
@@ -112,13 +112,13 @@ char *output_scsv(curve_t *curve, const config_t *cfg) {
 	return result;
 }
 
-char *output_scsv_separator(const config_t *cfg) { return output_malloc("\n"); }
+char *output_scsv_separator() { return output_malloc("\n"); }
 
-char *output_scsv_begin(const config_t *cfg) { return NULL; }
+char *output_scsv_begin() { return NULL; }
 
-char *output_scsv_end(const config_t *cfg) { return output_malloc("\n"); }
+char *output_scsv_end() { return output_malloc("\n"); }
 
-static JSON_Value *output_jjson(curve_t *curve, const config_t *cfg) {
+static JSON_Value *output_jjson(curve_t *curve) {
 	pari_sp ltop = avma;
 	// root object/value is curve
 	JSON_Value *root_value = json_value_init_object();
@@ -242,65 +242,65 @@ static JSON_Value *output_jjson(curve_t *curve, const config_t *cfg) {
 	return root_value;
 }
 
-char *output_sjson(curve_t *curve, const config_t *cfg) {
-	JSON_Value *root_value = output_jjson(curve, cfg);
+char *output_sjson(curve_t *curve) {
+	JSON_Value *root_value = output_jjson(curve);
 	char *result = json_serialize_to_string_pretty(root_value);
 	json_value_free(root_value);
 
 	return result;
 }
 
-char *output_sjson_separator(const config_t *cfg) {
+char *output_sjson_separator() {
 	return output_malloc(",\n");
 }
 
-char *output_sjson_begin(const config_t *cfg) { return output_malloc("[\n"); }
+char *output_sjson_begin() { return output_malloc("[\n"); }
 
-char *output_sjson_end(const config_t *cfg) { return output_malloc("]\n"); }
+char *output_sjson_end() { return output_malloc("]\n"); }
 
-void output_f(FILE *out, curve_t *curve, const config_t *cfg) {
-	char *s = output_s(curve, cfg);
+void output_f(FILE *out, curve_t *curve) {
+	char *s = output_s(curve);
 	if (s) {
 		fprintf(out, "%s", s);
 		try_free(s);
 	}
 }
 
-void output_o(curve_t *curve, const config_t *cfg) {
-	output_f(out, curve, cfg);
+void output_o(curve_t *curve) {
+	output_f(out, curve);
 }
 
-void output_f_separator(FILE *out, const config_t *cfg) {
-	char *s = output_s_separator(cfg);
+void output_f_separator(FILE *out) {
+	char *s = output_s_separator();
 	if (s) {
 		fprintf(out, "%s", s);
 		try_free(s);
 	}
 }
 
-void output_o_separator(const config_t *cfg) { output_f_separator(out, cfg); }
+void output_o_separator() { output_f_separator(out); }
 
-void output_f_begin(FILE *out, const config_t *cfg) {
-	char *s = output_s_begin(cfg);
+void output_f_begin(FILE *out) {
+	char *s = output_s_begin();
 	if (s) {
 		fprintf(out, "%s", s);
 		try_free(s);
 	}
 }
 
-void output_o_begin(const config_t *cfg) { output_f_begin(out, cfg); }
+void output_o_begin() { output_f_begin(out); }
 
-void output_f_end(FILE *out, const config_t *cfg) {
-	char *s = output_s_end(cfg);
+void output_f_end(FILE *out) {
+	char *s = output_s_end();
 	if (s) {
 		fprintf(out, "%s", s);
 		try_free(s);
 	}
 }
 
-void output_o_end(const config_t *cfg) { output_f_end(out, cfg); }
+void output_o_end() { output_f_end(out); }
 
-bool output_init(const config_t *cfg) {
+bool output_init() {
 	json_set_allocation_functions(try_malloc, try_free);
 
 	if (cfg->output) {
diff --git a/src/io/output.h b/src/io/output.h
index 0c3f22f..7ce8018 100644
--- a/src/io/output.h
+++ b/src/io/output.h
@@ -53,154 +53,133 @@
 #endif  // DEBUG
 
 #define verbose_log(...) \
-	if (cfg->verbose) fprintf(verbose, __VA_ARGS__)
+	if (cfg->verbose) pari_fprintf(verbose, __VA_ARGS__)
 
-#define output_log(...) fprintf(out, __VA_ARGS__)
+#define output_log(...) pari_fprintf(out, __VA_ARGS__)
 
 /**
  * @brief Output curve to a malloc'ed string in CSV format.
  * @param curve
- * @param config
  * @return
  */
-char *output_scsv(curve_t *curve, const config_t *cfg);
+char *output_scsv(curve_t *curve);
 
 /**
- * @brief Output CSV separator(newline) to a malloc'ed string in CSV
- * format.
- * @param cfg
+ * @brief Output CSV separator(newline) to a malloc'ed string in CSV format.
  * @return
  */
-char *output_scsv_separator(const config_t *cfg);
+char *output_scsv_separator();
 
 /**
  * @brief Output CSV output header to a malloc'ed string in CSV format.
- * @param cfg
  * @return
  */
-char *output_scsv_begin(const config_t *cfg);
+char *output_scsv_begin();
 
 /**
  * @brief Output CSV output footer to a malloc'ed string in CSV format.
- * @param cfg
  * @return
  */
-char *output_scsv_end(const config_t *cfg);
+char *output_scsv_end();
 
 /**
  * @brief Output curve to a malloc'ed string in JSON format.
  * @param curve
- * @param config
  * @return
  */
-char *output_sjson(curve_t *curve, const config_t *cfg);
+char *output_sjson(curve_t *curve);
 
 /**
  * @brief Output JSON separator(a ",\n") to a malloc'ed string in CSV
  * format.
- * @param cfg
  * @return
  */
-char *output_sjson_separator(const config_t *cfg);
+char *output_sjson_separator();
 
 /**
  * @brief Output JSON output header(a "[") to a malloc'ed string in CSV
  * format.
- * @param cfg
  * @return
  */
-char *output_sjson_begin(const config_t *cfg);
+char *output_sjson_begin();
 
 /**
  * @brief Output JSON output footer(a "]") to a malloc'ed string in CSV
  * format.
- * @param cfg
  * @return
  */
-char *output_sjson_end(const config_t *cfg);
+char *output_sjson_end();
 
 /**
  * @brief Output curve to a malloc'ed string in configured format.
  * @param curve
- * @param config
  * @return
  */
-char *(*output_s)(curve_t *curve, const config_t *cfg);
+char *(*output_s)(curve_t *curve);
 
 /**
  * @brief Output curve to a FILE *out in configured format.
  * @param out
  * @param curve
- * @param config
  */
-void output_f(FILE *out, curve_t *curve, const config_t *cfg);
+void output_f(FILE *out, curve_t *curve);
 
 /**
  * @brief Output curve to configured output in configured format.
  * @param curve
- * @param config
  */
-void output_o(curve_t *curve, const config_t *cfg);
+void output_o(curve_t *curve);
 
 /**
  * @brief Output separator to a malloc'ed string in configured format.
- * @param cfg
  * @return
  */
-char *(*output_s_separator)(const config_t *cfg);
+char *(*output_s_separator)();
 
 /**
  * @brief Output separator to a FILE *out in configured format.
  * @param out
- * @param cfg
  */
-void output_f_separator(FILE *out, const config_t *cfg);
+void output_f_separator(FILE *out);
 
 /**
  * @brief Output separator to configured output in configured format.
- * @param cfg
  */
-void output_o_separator(const config_t *cfg);
+void output_o_separator();
 
 /**
  * @brief Output header to a malloc'ed string in configured format.
- * @param cfg
  * @return
  */
-char *(*output_s_begin)(const config_t *cfg);
+char *(*output_s_begin)();
 
 /**
  * @brief Output header to a FILE *out in configured format.
  * @param out
- * @param cfg
  */
-void output_f_begin(FILE *out, const config_t *cfg);
+void output_f_begin(FILE *out);
 
 /**
  * @brief Output header to configured output in configured format.
- * @param cfg
  */
-void output_o_begin(const config_t *cfg);
+void output_o_begin();
 
 /**
  * @brief Output footer to a malloc'ed string in configured format.
- * @param cfg
  * @return
  */
-char *(*output_s_end)(const config_t *cfg);
+char *(*output_s_end)();
 
 /**
  * @brief Output footer to a FILE *out in configured format.
  * @param out
- * @param cfg
  */
-void output_f_end(FILE *out, const config_t *cfg);
+void output_f_end(FILE *out);
 
 /**
  * @brief Output header to configured output in configured format.
- * @param cfg
  */
-void output_o_end(const config_t *cfg);
+void output_o_end();
 
 /**
  * @brief Configured output FILE*.
@@ -219,10 +198,9 @@ extern FILE *verbose;
 
 /**
  * @brief Initialize output based on cfg.
- * @param cfg
  * @return whether the initialization was successful
  */
-bool output_init(const config_t *cfg);
+bool output_init();
 
 /**
  * @brief Deinitialize output.
diff --git a/src/math/subgroups.c b/src/math/subgroups.c
index 45523ad..aac58f0 100644
--- a/src/math/subgroups.c
+++ b/src/math/subgroups.c
@@ -125,7 +125,7 @@ static GEN subgroups_2n(const curve_t *curve, size_t min_bits) {
 	return subgroups_2n_gens(curve, min_bits);
 }
 
-GEN subgroups_prime(const curve_t *curve, const config_t *cfg) {
+GEN subgroups_prime(const curve_t *curve) {
 	if (cfg->prime || isprime(curve->order)) {
 		return gtovec(curve->order);
 	}
@@ -133,7 +133,7 @@ GEN subgroups_prime(const curve_t *curve, const config_t *cfg) {
 	return subgroups_factors(curve->order);
 }
 
-GEN subgroups_nonprime(const curve_t *curve, const config_t *cfg) {
+GEN subgroups_nonprime(const curve_t *curve) {
 	if (cfg->prime || isprime(curve->order)) {
 		return NULL;
 	}
@@ -141,7 +141,7 @@ GEN subgroups_nonprime(const curve_t *curve, const config_t *cfg) {
 	return subgroups_2n(curve, 1);
 }
 
-GEN subgroups_all(const curve_t *curve, const config_t *cfg) {
+GEN subgroups_all(const curve_t *curve) {
 	if (cfg->prime || isprime(curve->order)) {
 		return gtovec(curve->order);
 	}
diff --git a/src/math/subgroups.h b/src/math/subgroups.h
index 1c11d4c..6cca10f 100644
--- a/src/math/subgroups.h
+++ b/src/math/subgroups.h
@@ -14,25 +14,22 @@
 /**
  * @brief Enumerates prime subgroup orders of a given curve.
  * @param curve
- * @param cfg
  * @return
  */
-GEN subgroups_prime(const curve_t *curve, const config_t *cfg);
+GEN subgroups_prime(const curve_t *curve);
 
 /**
  * @brief Enumerates nonprime subgroup orders of a given curve.
  * @param curve
- * @param cfg
  * @return
  */
-GEN subgroups_nonprime(const curve_t *curve, const config_t *cfg);
+GEN subgroups_nonprime(const curve_t *curve);
 
 /**
  * @brief Enumerates all subgroup orders of a given curve.
  * @param curve
- * @param cfg
  * @return
  */
-GEN subgroups_all(const curve_t *curve, const config_t *cfg);
+GEN subgroups_all(const curve_t *curve);
 
 #endif  // ECGEN_SUBGROUPS_H
diff --git a/src/misc/config.c b/src/misc/config.c
index 466ec92..bffde82 100644
--- a/src/misc/config.c
+++ b/src/misc/config.c
@@ -4,4 +4,5 @@
  */
 #include "config.h"
 
-config_t cfg;
\ No newline at end of file
+config_t cfg_s;
+config_t *cfg = &cfg_s;
\ No newline at end of file
diff --git a/src/misc/config.h b/src/misc/config.h
index f93cfc3..0a534ef 100644
--- a/src/misc/config.h
+++ b/src/misc/config.h
@@ -100,6 +100,7 @@ typedef struct {
 	unsigned long hex_digits;
 } config_t;
 
-extern config_t cfg;
+extern config_t cfg_s;
+extern config_t *cfg;
 
 #endif  // ECGEN_CONFIG_H
diff --git a/src/misc/types.h b/src/misc/types.h
index d20ed2b..3cb3fd4 100644
--- a/src/misc/types.h
+++ b/src/misc/types.h
@@ -114,35 +114,30 @@ typedef struct {
 /**
  * @brief A generator function type.
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args Current optional generator argument
  * @param state The current generation state
  * @return state diff
  */
 #define GENERATOR(gen_name)                                        \
-	int gen_name(curve_t *curve, const config_t *cfg, arg_t *args, \
-	             offset_e state)
+	int gen_name(curve_t *curve, arg_t *args, offset_e state)
 
 typedef GENERATOR((*gen_f));
 
 /**
  * @brief An unroll function type
  * @param curve
- * @param cfg
  * @param from
  * @param to
  * @return
  */
 #define UNROLL(unroll_name)                                            \
-	int unroll_name(curve_t *curve, const config_t *cfg, pari_sp from, \
-	                pari_sp to)
+	int unroll_name(curve_t *curve, pari_sp from, pari_sp to)
 
 typedef UNROLL((*unroll_f));
 
 /**
  * @brief A check function type.
  * @param curve A curve_t being checked
- * @param cfg An application config
  * @param args Current optional generator argument
  * @return state diff
  */
@@ -162,7 +157,6 @@ typedef struct {
  * GENERATOR(gen_f)
  *
  * @param curve A curve_t being generated
- * @param cfg An application config
  * @param args unused
  * @return state diff
  */
@@ -172,7 +166,6 @@ GENERATOR(gen_skip);
  * CHECK(check_f)
  *
  * @param curve A curve_t being checked
- * @param cfg An application config
  * @param args unused
  * @return
  */
@@ -182,7 +175,6 @@ CHECK(check_skip);
  * UNROLL(unroll_f)
  *
  * @param curve
- * @param cfg
  * @param from
  * @param to
  * @return