Refactor table generation

6 files changed, 201 insertions, 129 deletions

diff --git a/src/nissy.c b/src/nissy.c
index fac7a20..5641dd9 100644
--- a/src/nissy.c
+++ b/src/nissy.c
@@ -10,6 +10,7 @@
 
 #include "nissy.h"
 
+_static int parse_h48_options(const char *, uint8_t *, uint8_t *, uint8_t *);
 _static int64_t write_result(cube_t, char [static 22]);
 
 /* TODO: add option to get DR, maybe C-only, E-only, eo... */
@@ -22,6 +23,36 @@ struct {
         GETCUBE_OPTIONS(NULL, NULL)
 };
 
+_static int
+parse_h48_options(const char *buf, uint8_t *h, uint8_t *k, uint8_t *maxdepth)
+{
+        int i;
+
+        /* TODO temporarily, options are in the form "h;k;maxdepth" */
+        if (h != NULL)
+                *h = atoi(buf);
+        for (i = 0; buf[i] != ';'; i++)
+                if (buf[i] == 0)
+                        goto parse_h48_options_error;
+        if (k != NULL)
+                *k = atoi(&buf[i+1]);
+        for (i = i+1; buf[i] != ';'; i++)
+                if (buf[i] == 0)
+                        goto parse_h48_options_error;
+        if (maxdepth != NULL)
+                *maxdepth = atoi(&buf[i+1]);
+
+        return (*h <= 11 && (*k == 2 || *k == 4) && *maxdepth <= 20) ? 0 : 1;
+
+parse_h48_options_error:
+        *h = 0;
+        *k = 0;
+        *maxdepth = 0;
+        LOG("Error parsing options: must be in \"h;k;maxdepth\" format "
+            " (instead it was \"%s\")\n", buf);
+        return -1;
+}
+
 _static int64_t
 write_result(cube_t cube, char result[static 22])
 {
@@ -163,19 +194,19 @@ nissy_gendata(
         void *data
 )
 {
+        int p;
         int64_t ret;
-        uint8_t i;
         gendata_h48_arg_t arg;
 
         arg.buf = data;
         if (!strcmp(solver, "h48")) {
-                /*  options are in the form "h;k;maxdepth" */
-                arg.h = atoi(options);
-                for (i = 0; options[i] != ';'; i++) ;
-                arg.k = atoi(&options[i+1]);
-                for (i = i+1; options[i] != ';'; i++) ;
-                arg.maxdepth = atoi(&options[i+1]);
-                ret = gendata_h48(&arg);
+                p = parse_h48_options(options, &arg.h, &arg.k, &arg.maxdepth);
+                if (p != 0) {
+                        LOG("gendata: ould not parse options\n");
+                        ret = -1;
+                } else {
+                        ret = gendata_h48(&arg);
+                }
         } else if (!strcmp(solver, "h48stats")) {
                 arg.h = 0;
                 arg.k = 4;
@@ -204,8 +235,9 @@ nissy_solve(
 )
 {
         cube_t c;
+        int p;
         int64_t ret;
-        int h;
+        uint8_t h, k;
 
         c = readcube_B32(cube);
 
@@ -241,11 +273,14 @@ nissy_solve(
 
         /* TODO define and use solve_options_t */
         if (!strcmp(solver, "h48")) {
-                h = atoi(options); /* TODO: better parsing */
-                ret = solve_h48(
-                    c, minmoves, maxmoves, maxsolutions,
-                    (uint8_t)h, data, solutions);
-                ret = -1;
+                p = parse_h48_options(options, &h, &k, NULL);
+                if (p != 0) {
+                        LOG("gendata: could not parse options\n");
+                        ret = -1;
+                } else {
+                        ret = solve_h48(c, minmoves, maxmoves, maxsolutions,
+                            h, k, data, solutions);
+                }
         } else if (!strcmp(solver, "h48stats")) {
                 ret = solve_h48stats(c, maxmoves, data, solutions);
         } else if (!strcmp(solver, "simple")) {
diff --git a/src/solvers/h48/gendata_full.h b/src/solvers/h48/gendata_full.h
index be234d9..2b1347f 100644
--- a/src/solvers/h48/gendata_full.h
+++ b/src/solvers/h48/gendata_full.h
@@ -1,10 +1,11 @@
-#define ESEP_NOEO             (COCSEP_CLASSES * (size_t)_12c4 * (size_t)_8c4)
-#define ESEP_MAX(h)           (ESEP_NOEO << (size_t)(h))
-#define ESEP_TABLESIZE(h, k)  (ESEP_MAX((h)) / ((size_t)8 / (size_t)(k)))
+#define H48_COORDMAX_NOEO    (COCSEP_CLASSES * (size_t)_12c4 * (size_t)_8c4)
+#define H48_COORDMAX(h)      (H48_COORDMAX_NOEO << (size_t)(h))
+#define H48_TABLESIZE(h, k)  (H48_COORDMAX((h)) / ((size_t)8 / (size_t)(k)))
 
-#define ESEP_IND(i)           ((uint32_t)(i) / UINT32_C(8))
-#define ESEP_SHIFT(i)         (UINT32_C(4) * ((uint32_t)(i) % UINT32_C(8)))
-#define ESEP_MASK(i)          ((_bit_u32(4) - (uint32_t)(1)) << ESEP_SHIFT(i))
+#define H48_COEFF(k)         (UINT32_C(32) / (uint32_t)(k))
+#define H48_INDEX(i, k)      ((uint32_t)(i) / H48_COEFF(k))
+#define H48_SHIFT(i, k)      ((uint32_t)(k) * ((uint32_t)(i) % H48_COEFF(k)))
+#define H48_MASK(i, k)       ((_bit_u32(k) - (uint32_t)(1)) << H48_SHIFT(i, k))
 
 #define MAXLEN 20
 
@@ -31,7 +32,12 @@ typedef struct {
         uint8_t h;
         uint8_t k;
         uint8_t maxdepth;
-        void * buf;
+        void *buf;
+        uint32_t *info;
+        uint32_t *cocsepdata;
+        uint32_t *h48data;
+        uint64_t selfsim[COCSEP_CLASSES];
+        cube_t crep[COCSEP_CLASSES];
 } gendata_h48_arg_t;
 
 typedef struct {
@@ -51,18 +57,18 @@ typedef struct {
         cube_t *crep;
 } bfsarg_esep_t;
 
-_static_inline uint8_t get_esep_pval(const uint32_t *, int64_t);
-_static_inline void set_esep_pval(uint32_t *, int64_t, uint8_t);
+_static_inline uint8_t get_esep_pval(const uint32_t *, int64_t, uint8_t);
+_static_inline void set_esep_pval(uint32_t *, int64_t, uint8_t, uint8_t);
 
 _static uint64_t gen_h48short(gendata_h48short_arg_t *);
 _static size_t gendata_h48(gendata_h48_arg_t *);
-_static size_t gendata_h48h0k4(void *, uint8_t);
+_static size_t gendata_h48h0k4(gendata_h48_arg_t *);
 _static int64_t gendata_h48h0k4_bfs(bfsarg_esep_t *);
 _static int64_t gendata_h48h0k4_bfs_fromdone(bfsarg_esep_t *);
 _static int64_t gendata_h48h0k4_bfs_fromnew(bfsarg_esep_t *);
-_static size_t gendata_h48k2(void *, uint8_t, uint8_t);
+_static size_t gendata_h48k2(gendata_h48_arg_t *);
 
-_static_inline int8_t get_h48_bound(cube_t, uint32_t, uint8_t, uint32_t *);
+_static_inline int8_t get_h48_bound(cube_t, uint32_t, uint8_t, uint8_t, uint32_t *);
 
 _static uint64_t
 gen_h48short(gendata_h48short_arg_t *arg)
@@ -108,14 +114,32 @@ gen_h48short(gendata_h48short_arg_t *arg)
 _static size_t
 gendata_h48(gendata_h48_arg_t *arg)
 {
+        static const size_t infosize = 88; /* TODO: change to e.g. 1024 */
+
+        size_t cocsepsize, h48size;
+
+        /* TODO: move info at the start */
+        arg->cocsepdata = (uint32_t *)arg->buf;
+        cocsepsize = gendata_cocsep(
+            (void *)arg->cocsepdata, arg->selfsim, arg->crep);
+        arg->h48data = arg->cocsepdata + (cocsepsize / sizeof(uint32_t));
+        arg->info = arg->h48data +
+            (H48_TABLESIZE(arg->h, arg->k) / sizeof(uint32_t));
+
+        if (arg->buf != NULL)
+                memset(arg->h48data, 0xFF, H48_TABLESIZE(arg->h, arg->k));
+
         if (arg->h == 0 && arg->k == 4) {
-                return gendata_h48h0k4(arg->buf, arg->maxdepth);
+                h48size = gendata_h48h0k4(arg);
         } else if (arg->k == 2) {
-                return gendata_h48k2(arg->buf, arg->h, arg->maxdepth);
+                h48size = gendata_h48k2(arg);
+        } else {
+                h48size = 0;
+                LOG("Cannot generate data for h = %" PRIu8 " and k = %" PRIu8
+                    " (not implemented yet)\n", arg->h, arg->k);
         }
 
-        LOG("Cannot generate data for h = %" PRIu8 " and k = %" PRIu8
-            " (not implemented yet)\n", arg->h, arg->k);
+        return infosize + cocsepsize + h48size;
 }
 
 /*
@@ -123,59 +147,61 @@ TODO description
 generating fixed table with h=0, k=4
 */
 _static size_t
-gendata_h48h0k4(void *buf, uint8_t maxdepth)
+gendata_h48h0k4(gendata_h48_arg_t *arg)
 {
-        uint32_t j, *buf32, *info, *cocsepdata;
-        bfsarg_esep_t arg;
+        uint32_t j;
+        bfsarg_esep_t bfsarg;
         int64_t sc, cc, esep_max;
+/*
         uint64_t selfsim[COCSEP_CLASSES];
         cube_t crep[COCSEP_CLASSES];
         size_t cocsepsize, infosize;
+*/
 
-        if (buf == NULL)
+        if (arg->buf == NULL)
                 goto gendata_h48h0k4_return_size;
-
-        /* TODO: move info at start of tables (all tables!) */
+/*
         cocsepsize = gendata_cocsep(buf, selfsim, crep);
         infosize = 88;
 
-        esep_max = (int64_t)ESEP_MAX(0);
         cocsepdata = (uint32_t *)buf;
         buf32 = cocsepdata + cocsepsize / 4;
-        info = buf32 + (ESEP_TABLESIZE(0, 4) / sizeof(uint32_t));
-        memset(buf32, 0xFF, ESEP_TABLESIZE(0, 4));
+        info = buf32 + (H48_TABLESIZE(0, 4) / sizeof(uint32_t));
+        memset(buf32, 0xFF, H48_TABLESIZE(0, 4));
+*/
 
-        sc = coord_h48(solved, cocsepdata, 0);
-        set_esep_pval(buf32, sc, 0);
-        info[1] = 1;
-        arg = (bfsarg_esep_t) {
-                .cocsepdata = cocsepdata,
-                .buf32 = buf32,
-                .selfsim = selfsim,
-                .crep = crep
+        esep_max = (int64_t)H48_COORDMAX(0);
+        sc = coord_h48(solved, arg->cocsepdata, 0);
+        set_esep_pval(arg->h48data, sc, 4, 0);
+        arg->info[1] = 1;
+        bfsarg = (bfsarg_esep_t) {
+                .cocsepdata = arg->cocsepdata,
+                .buf32 = arg->h48data,
+                .selfsim = arg->selfsim,
+                .crep = arg->crep
         };
         for (
-                arg.done = 1, arg.depth = 1, cc = 0;
-                arg.done < esep_max && arg.depth <= maxdepth;
-                arg.depth++
+                bfsarg.done = 1, bfsarg.depth = 1, cc = 0;
+                bfsarg.done < esep_max && bfsarg.depth <= arg->maxdepth;
+                bfsarg.depth++
         ) {
-                LOG("esep: generating depth %" PRIu8 "\n", arg.depth);
-                cc = gendata_h48h0k4_bfs(&arg);
-                arg.done += cc;
-                info[arg.depth+1] = cc;
+                LOG("esep: generating depth %" PRIu8 "\n", bfsarg.depth);
+                cc = gendata_h48h0k4_bfs(&bfsarg);
+                bfsarg.done += cc;
+                arg->info[bfsarg.depth+1] = cc;
                 LOG("found %" PRId64 "\n", cc);
         }
 
-        info[0] = arg.depth-1;
+        arg->info[0] = bfsarg.depth-1;
 
         LOG("h48 pruning table computed\n");
-        LOG("Maximum pruning value: %" PRIu32 "\n", info[0]);
+        LOG("Maximum pruning value: %" PRIu32 "\n", arg->info[0]);
         LOG("Pruning value distribution:\n");
-        for (j = 0; j <= info[0]; j++)
-                LOG("%" PRIu8 ":\t%" PRIu32 "\n", j, info[j+1]);
+        for (j = 0; j <= arg->info[0]; j++)
+                LOG("%" PRIu8 ":\t%" PRIu32 "\n", j, arg->info[j+1]);
 
 gendata_h48h0k4_return_size:
-        return cocsepsize + ESEP_TABLESIZE(0, 4) + infosize;
+        return H48_TABLESIZE(0, 4);
 }
 
 _static int64_t
@@ -197,20 +223,20 @@ gendata_h48h0k4_bfs_fromdone(bfsarg_esep_t *arg)
         int64_t i, j, k;
         cube_t cube, moved;
 
-        for (i = 0, cc = 0; i < (int64_t)ESEP_MAX(0); i++) {
-                c = get_esep_pval(arg->buf32, i);
+        for (i = 0, cc = 0; i < (int64_t)H48_COORDMAX(0); i++) {
+                c = get_esep_pval(arg->buf32, i, 4);
                 if (c != arg->depth - 1)
                         continue;
                 cube = invcoord_h48(i, arg->crep, 0);
                 for (m = 0; m < 18; m++) {
                         moved = move(cube, m);
                         j = coord_h48(moved, arg->cocsepdata, 0);
-                        if (get_esep_pval(arg->buf32, j) <= arg->depth)
+                        if (get_esep_pval(arg->buf32, j, 4) <= arg->depth)
                                 continue;
                         _foreach_h48sim(moved, arg->cocsepdata, arg->selfsim, 0,
                                 k = coord_h48(moved, arg->cocsepdata, 0);
-                                x = get_esep_pval(arg->buf32, k);
-                                set_esep_pval(arg->buf32, k, arg->depth);
+                                x = get_esep_pval(arg->buf32, k, 4);
+                                set_esep_pval(arg->buf32, k, 4, arg->depth);
                                 cc += x != arg->depth;
                         )
                 }
@@ -227,21 +253,21 @@ gendata_h48h0k4_bfs_fromnew(bfsarg_esep_t *arg)
         int64_t i, j;
         cube_t cube, moved;
 
-        for (i = 0, cc = 0; i < (int64_t)ESEP_MAX(0); i++) {
-                c = get_esep_pval(arg->buf32, i);
+        for (i = 0, cc = 0; i < (int64_t)H48_COORDMAX(0); i++) {
+                c = get_esep_pval(arg->buf32, i, 4);
                 if (c != 0xF)
                         continue;
                 cube = invcoord_h48(i, arg->crep, 0);
                 for (m = 0; m < 18; m++) {
                         moved = move(cube, m);
                         j = coord_h48(moved, arg->cocsepdata, 0);
-                        x = get_esep_pval(arg->buf32, j);
+                        x = get_esep_pval(arg->buf32, j, 4);
                         if (x >= arg->depth)
                                 continue;
                         _foreach_h48sim(cube, arg->cocsepdata, arg->selfsim, 0,
                                 j = coord_h48(cube, arg->cocsepdata, 0);
-                                x = get_esep_pval(arg->buf32, j);
-                                set_esep_pval(arg->buf32, j, arg->depth);
+                                x = get_esep_pval(arg->buf32, j, 4);
+                                set_esep_pval(arg->buf32, j, 4, arg->depth);
                                 cc += x == 0xF;
                         )
                         break; /* Enough to find one, skip the rest */
@@ -252,11 +278,12 @@ gendata_h48h0k4_bfs_fromnew(bfsarg_esep_t *arg)
 }
 
 _static size_t
-gendata_h48k2(void *buf, uint8_t h, uint8_t maxdepth)
+gendata_h48k2(gendata_h48_arg_t *arg)
 {
-        static uint64_t capacity = 10000019; /* First prime after 1e8 */
-        static uint64_t randomizer = 10000079; /* Second prime after 1e8 */
-        static uint8_t base[] = {
+        static const uint8_t shortdepth = 8;
+        static const uint64_t capacity = 10000019;
+        static const uint64_t randomizer = 10000079;
+        static const uint8_t base[] = {
                 [0]  = 8,
                 [1]  = 8,
                 [2]  = 8,
@@ -272,58 +299,53 @@ gendata_h48k2(void *buf, uint8_t h, uint8_t maxdepth)
         };
 
         uint64_t nshort;
-        uint32_t *buf32, *info, *cocsepdata;
-        h48map_t depth8cubes;
+        h48map_t shortcubes;
         gendata_h48short_arg_t shortarg;
-        uint64_t selfsim[COCSEP_CLASSES];
-        cube_t crep[COCSEP_CLASSES];
-        size_t cocsepsize, infosize;
 
-        DBG_ASSERT(base[h] == 8, 0, "Only implemented for h <= 3 (base 8)\n");
+        DBG_ASSERT(base[arg->h] == 8, 0, "Only implemented for h <= 3 (base 8)\n");
 
-        if (buf == NULL)
+        if (arg->buf == NULL)
                 goto gendata_h48k2_return_size;
 
-        cocsepdata = (uint32_t *)buf;
-        cocsepsize = gendata_cocsep(buf, selfsim, crep);
-        infosize = 88;
-
-        h48map_create(&depth8cubes, capacity, randomizer);
+        LOG("Computing depth <=%" PRIu8 "\n", shortdepth)
+        h48map_create(&shortcubes, capacity, randomizer);
         shortarg = (gendata_h48short_arg_t) {
-                .maxdepth = 8,
-                .cocsepdata = cocsepdata,
-                .crep = crep,
-                .selfsim = selfsim,
-                .map = &depth8cubes
+                .maxdepth = shortdepth,
+                .cocsepdata = arg->cocsepdata,
+                .crep = arg->crep,
+                .selfsim = arg->selfsim,
+                .map = &shortcubes
         };
-
         nshort = gen_h48short(&shortarg);
-        LOG("%" PRIu64 "\n", nshort);
+        LOG("Found %" PRIu64 "\n", nshort);
+
+        /* TODO: loop over map, set all found to 0, do 2 moves each */
+        LOG("The rest is not implemented yet\n");
 
-        h48map_destroy(&depth8cubes);
+        h48map_destroy(&shortcubes);
 
 gendata_h48k2_return_size:
-        return cocsepsize + ESEP_TABLESIZE(h, 2) + infosize;
+        return H48_TABLESIZE(arg->h, 2);
 }
 
 _static_inline uint8_t
-get_esep_pval(const uint32_t *buf32, int64_t i)
+get_esep_pval(const uint32_t *buf32, int64_t i, uint8_t k)
 {
-        return (buf32[ESEP_IND(i)] & ESEP_MASK(i)) >> ESEP_SHIFT(i);
+        return (buf32[H48_INDEX(i, k)] & H48_MASK(i, k)) >> H48_SHIFT(i, k);
 }
 
 _static_inline void
-set_esep_pval(uint32_t *buf32, int64_t i, uint8_t val)
+set_esep_pval(uint32_t *buf32, int64_t i, uint8_t k, uint8_t val)
 {
-        buf32[ESEP_IND(i)] =
-            (buf32[ESEP_IND(i)] & (~ESEP_MASK(i))) | (val << ESEP_SHIFT(i));
+        buf32[H48_INDEX(i, k)] = (buf32[H48_INDEX(i, k)] & (~H48_MASK(i, k)))
+            | (val << H48_SHIFT(i, k));
 }
 
 _static_inline int8_t
-get_h48_bound(cube_t cube, uint32_t cdata, uint8_t h, uint32_t *h48data)
+get_h48_bound(cube_t cube, uint32_t cdata, uint8_t h, uint8_t k, uint32_t *h48data)
 {
         int64_t coord;
 
         coord = coord_h48_edges(cube, COCLASS(cdata), TTREP(cdata), h);
-        return get_esep_pval(h48data, coord);
+        return get_esep_pval(h48data, coord, k);
 }
diff --git a/src/solvers/h48/solve.h b/src/solvers/h48/solve.h
index 8531a40..0843792 100644
--- a/src/solvers/h48/solve.h
+++ b/src/solvers/h48/solve.h
@@ -7,6 +7,7 @@ typedef struct {
         int64_t *nsols;
         int64_t maxsolutions;
         uint8_t h;
+        uint8_t k;
         uint32_t *cocsepdata;
         uint32_t *h48data;
         char **nextsol;
@@ -26,7 +27,7 @@ _static void solve_h48_appendsolution(dfsarg_solveh48_t *);
 _static_inline bool solve_h48_stop(dfsarg_solveh48_t *);
 _static int64_t solve_h48_dfs(dfsarg_solveh48_t *);
 _static int64_t solve_h48(
-    cube_t, int8_t, int8_t, int8_t, uint8_t, const void *, char *);
+    cube_t, int8_t, int8_t, int8_t, uint8_t, uint8_t, const void *, char *);
 
 _static int64_t solve_h48stats_dfs(dfsarg_solveh48stats_t *);
 _static int64_t solve_h48stats(cube_t, int8_t, const void *, char [static 12]);
@@ -59,12 +60,12 @@ solve_h48_stop(dfsarg_solveh48_t *arg)
                 return true;
 
 /*
-        bound = get_h48_bound(arg->cube, data, arg->h, arg->h48data);
+        bound = get_h48_bound(arg->cube, data, arg->h, arg->k, arg->h48data);
 LOG("Using pval %" PRId8 "\n", bound);
         if (bound + arg->nmoves > arg->depth)
                 return true;
 
-        bound = get_h48_bound(arg->inverse, data_inv, arg->h, arg->h48data);
+        bound = get_h48_bound(arg->inverse, data_inv, arg->h, arg->k, arg->h48data);
         if (bound + arg->nmoves > arg->depth)
                 return true;
 */
@@ -119,6 +120,7 @@ solve_h48(
         int8_t maxmoves,
         int8_t maxsolutions,
         uint8_t h,
+        uint8_t k,
         const void *data,
         char *solutions
 )
@@ -132,6 +134,7 @@ solve_h48(
                 .nsols = &nsols,
                 .maxsolutions = maxsolutions,
                 .h = h,
+                .k = k,
                 .cocsepdata = (uint32_t *)data,
                 .h48data = ((uint32_t *)data) + COCSEP_FULLSIZE / 4,
                 .nextsol = &solutions
@@ -175,7 +178,7 @@ solve_h48stats_dfs(dfsarg_solveh48stats_t *arg)
 
         /* Check h48 lower bound for h=0 (esep, but no eo) */
         coord = coord_h48_edges(arg->cube, COCLASS(d), TTREP(d), 0);
-        bound = get_esep_pval(arg->h48data, coord);
+        bound = get_esep_pval(arg->h48data, coord, 4);
         if (bound + arg->nmoves > arg->depth)
                 return 0;
         
diff --git a/test/112_gendata_h48/gendata_h48_tests.c b/test/112_gendata_h48/gendata_h48_tests.c
index 485d9d0..d6c6cb2 100644
--- a/test/112_gendata_h48/gendata_h48_tests.c
+++ b/test/112_gendata_h48/gendata_h48_tests.c
@@ -1,43 +1,50 @@
 #include "../test.h"
 
+#define COCSEP_CLASSES 3393
 #define COCSEPSIZE 1119792
-#define ETABLESIZE ((3393 * 495 * 70) >> 1)
 
-int64_t gendata_h48h0k4(void *, uint8_t);
+typedef struct {
+        uint8_t h;
+        uint8_t k;
+        uint8_t maxdepth;
+        void *buf;
+        uint32_t *info;
+        uint32_t *cocsepdata;
+        uint32_t *h48data;
+        uint64_t selfsim[COCSEP_CLASSES];
+        cube_t crep[COCSEP_CLASSES];
+} gendata_h48_arg_t;
 
-int64_t gendata_h48_fixture(void *buf, uint8_t maxdepth, uint8_t h) {
-        if (h == 0)
-                return gendata_h48h0k4(buf, maxdepth);
-        fprintf(stderr, "Error: gendata h48 for h>0 not implemented yet\n");
-        exit(1);
-}
+int64_t gendata_h48(gendata_h48_arg_t *);
 
 void run(void) {
         char str[STRLENMAX];
-        uint8_t i, maxdepth, h;
-        uint32_t *buf, *h48info;
-        size_t result;
+        uint8_t i;
+        gendata_h48_arg_t arg;
+        size_t result, sz;
 
         fgets(str, STRLENMAX, stdin);
-        maxdepth = atoi(str);
+        arg.maxdepth = atoi(str);
         fgets(str, STRLENMAX, stdin);
-        h = atoi(str);
+        arg.h = atoi(str);
+        arg.k = 4;
 
-        buf = (uint32_t *)malloc(sizeof(uint32_t) * 60000000);
-        result = gendata_h48_fixture(buf, maxdepth, h);
-        h48info = buf + (ETABLESIZE + COCSEPSIZE) / 4;
+        sz = gendata_h48(&arg); /* With buf = NULL returns data size */
+        arg.buf = malloc(sz);
+        result = gendata_h48(&arg);
 
         printf("%zu\n\n", result);
 
         printf("cocsepdata:\n");
-        printf("Classes: %" PRIu32 "\n", buf[COCSEPSIZE/4-12]);
-        printf("Max value: %" PRIu32 "\n", buf[COCSEPSIZE/4-11]);
+        printf("Classes: %" PRIu32 "\n", arg.cocsepdata[COCSEPSIZE/4-12]);
+        printf("Max value: %" PRIu32 "\n", arg.cocsepdata[COCSEPSIZE/4-11]);
         for (i = 0; i < 10; i++)
-                printf("%" PRIu32 ": %" PRIu32 "\n", i, buf[COCSEPSIZE/4-10+i]);
+                printf("%" PRIu32 ": %" PRIu32 "\n",
+                    i, arg.cocsepdata[COCSEPSIZE/4-10+i]);
 
         printf("\nh48:\n");
-        for (i = 0; i < maxdepth+1; i++)
-                printf("%" PRIu32 ": %" PRIu32 "\n", i, h48info[i+1]);
+        for (i = 0; i < arg.maxdepth+1; i++)
+                printf("%" PRIu32 ": %" PRIu32 "\n", i, arg.info[i+1]);
 
-        free(buf);
+        free(arg.buf);
 }
diff --git a/test/113_gen_h48short/gen_h48short.c b/test/113_gen_h48short/gen_h48short.c
index 92d346a..335821a 100644
--- a/test/113_gen_h48short/gen_h48short.c
+++ b/test/113_gen_h48short/gen_h48short.c
@@ -8,6 +8,11 @@ typedef struct {
         uint64_t capacity;
         uint64_t randomizer;
         uint64_t *table;
+        uint32_t *info;
+        uint32_t *cocsepdata;
+        uint32_t *h48data;
+        uint64_t selfsim[COCSEP_CLASSES];
+        cube_t crep[COCSEP_CLASSES];
 } h48map_t;
 
 typedef struct {
diff --git a/tools/001_gendata_h48/gendata_h48.c b/tools/001_gendata_h48/gendata_h48.c
index da0b4ad..a73f818 100644
--- a/tools/001_gendata_h48/gendata_h48.c
+++ b/tools/001_gendata_h48/gendata_h48.c
@@ -3,8 +3,8 @@
 
 #define MAXDEPTH 20
 #define HVALUE 0
-#define OPTIONS "0;20"
-#define LONGOPTIONS "h = 0, max depth = 20"
+#define OPTIONS "0;4;20"
+#define LONGOPTIONS "h = 0, k = 4, max depth = 20"
 
 #define COCSEPSIZE 1119792
 #define ETABLESIZE(h) (((3393 * 495 * 70) >> 1) << (size_t)(h))