17 files changed, 387 insertions, 122 deletions

diff --git a/.gitignore b/.gitignore
index eaaa09e..bff1f6a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 config.mk
 gen
 debuggen
+flamegraph.html
 utils/.DS_Store
 perf.data
 perf.data.old
diff --git a/README.md b/README.md
index 8e23065..09b5881 100644
--- a/README.md
+++ b/README.md
@@ -14,9 +14,8 @@ In the future this project may evolve as a new "back-end" for the classic
 
 ## Building
 
-First run the configuration script to detect the system
-configuration. This is going to select a C compiler and
-architecture-specific optimizations.
+First run the configuration script to detect the system configuration.
+This is going to select a C compiler and architecture-specific optimizations.
 
 ```
 $ ./configure.sh
@@ -25,10 +24,11 @@ $ ./configure.sh
 These settings can be overridden, for example:
 
 ```
-$ CC=clang ./configure.sh           # Force use of clang instead of default cc
 $ THREADS=3 CC=gcc ./configure.sh   # Use 3 threads and compile with gcc
 ```
 
+All the configuration-time options are described in the `configure.sh` script.
+
 Once the configuration is done, you can build with make
 
 ```
diff --git a/configure.sh b/configure.sh
index fcf2dce..e61a163 100755
--- a/configure.sh
+++ b/configure.sh
@@ -1,5 +1,40 @@
 #!/bin/sh
 
+# The following environment variables can be used to configure the build:
+#
+# CC="compiler"
+# Specify the compiler to use.
+# By default, cc will be used.
+# The string "compiler" must be the name of an executable in $PATH.
+#
+# ARCH="architecture"
+# You can use this variable to build for a different architecture, for example
+# if you want to cross-compile or to use the portable version.
+# By default, the build script will detect which architecture it is running on.
+# The string "architecture" must be one of "AVX2", "NEON" or "PORTABLE".
+#
+# THREADS=n
+# Choose how many threads to use for multi-threaded oerations.
+# By default, 16 threads will be used (TODO: in the future this will be
+# determined base on the system).
+# The number n must be between 1 and 128.
+#
+# SANITIZE="option1,option2,..."
+# Add the options "-fsanitize=option1", "-fsanitize=option2", ... to the
+# compilation command when compiling in debug mode.
+# By default, "-fsanitize=address" and "-fsanitize=undefined" will be used,
+# if available. If this variable is set, the default is overridden.
+# No check is performed on the given sanitizers, make sure that the ones you
+# choose are available on your system and compatible with each other.
+#
+# Examples
+#
+# 1. Build using clang and 8 threads
+#    CC=clang THREADS=8 ./configure.sh && make
+#
+# 2. Build using thread and undefined behavior sanitizers when in debug mode
+#    SANITIZE="thread,undefined" ./configures && make
+
 greparch() {
         $CC -march=native -dM -E - </dev/null 2>/dev/null | grep "$1"
 }
@@ -53,23 +88,33 @@ validatecc
 validatethreads
 validatearch
 
-STD="-std=c99"
+STD="-std=c11"
 WFLAGS="-pedantic -Wall -Wextra"
 WNOFLAGS="-Wno-unused-parameter -Wno-unused-function -Wno-unknown-pragmas"
 
 [ "$ARCH" = "AVX2" ] && AVX="-mavx2"
-[ -n "$(grepsan address)" ] && ADDR="-fsanitize=address"
-[ -n "$(grepsan undefined)" ] && UNDEF="-fsanitize=undefined"
-SAN="$ADDR $UNDEF"
+
+if [ -n "$SANITIZE" ]; then
+        # Use the user-specified comma-separated sanitizers
+        for san in $(echo "$SANITIZE" | tr ',' '\n'); do
+                SAN="$SAN -fsanitize=$san"
+        done
+else
+        # No sanitizer specified, use "address" and "undefined" if present
+        [ -n "$(grepsan address)" ] && ADDR="-fsanitize=address"
+        [ -n "$(grepsan undefined)" ] && UNDEF="-fsanitize=undefined"
+        SAN="$ADDR $UNDEF"
+fi
 LIBS="-lpthread"
 
 CFLAGS="$STD $LIBS $WFLAGS $WNOFLAGS $AVX -O3"
 DBGFLAGS="$STD $LIBS $WFLAGS $WNOFLAGS $SAN $AVX -g3 -DDEBUG"
 MACROS="-DTHREADS=$THREADS -D$ARCH"
 
+echo "Compiler: $CC"
 echo "Selected architecture: $ARCH"
 echo "Number of threads: $THREADS"
-echo "Compiler: $CC"
+echo "Sanitizer options (debug build only): $SAN"
 
 {
 echo "ARCH = $ARCH";
diff --git a/src/solvers/h48/gendata_h48.h b/src/solvers/h48/gendata_h48.h
index e8ffee3..2a62b1d 100644
--- a/src/solvers/h48/gendata_h48.h
+++ b/src/solvers/h48/gendata_h48.h
@@ -344,7 +344,7 @@ gendata_h48k2(gendata_h48_arg_t *arg)
 
         uint8_t t, selectedbase, *table;
         int64_t j;
-        uint64_t nshort, i, ii, inext, count;
+        uint64_t i, ii, inext, count;
         h48map_t shortcubes;
         gendata_h48short_arg_t shortarg;
         h48k2_dfs_arg_t dfsarg[THREADS];
@@ -367,8 +367,7 @@ gendata_h48k2(gendata_h48_arg_t *arg)
                 .selfsim = arg->selfsim,
                 .map = &shortcubes
         };
-        nshort = gendata_h48short(&shortarg);
-        LOG("Cubes in <= %" PRIu8 " moves: %" PRIu64 "\n", shortdepth, nshort);
+        gendata_h48short(&shortarg);
 
         selectedbase = base[arg->h];
         arg->info = (tableinfo_t) {
@@ -434,6 +433,7 @@ gendata_h48k2_return_size:
 STATIC void *
 gendata_h48k2_runthread(void *arg)
 {
+        uint64_t count, coord, mutex;
         kvpair_t kv;
         h48k2_dfs_arg_t *dfsarg;
 
@@ -447,15 +447,22 @@ gendata_h48k2_runthread(void *arg)
                         pthread_mutex_unlock(dfsarg->shortcubes_mutex);
                         break;
                 }
-                (*dfsarg->count)++;
-                if (*dfsarg->count % UINT64_C(1000000) == 0)
-                        LOG("Processing %" PRIu64 "th short cube\n",
-                            *dfsarg->count);
-
+                count = ++(*dfsarg->count);
                 pthread_mutex_unlock(dfsarg->shortcubes_mutex);
 
-                dfsarg->cube = invcoord_h48(kv.key, dfsarg->crep, 11);
-                gendata_h48k2_dfs(dfsarg);
+                if (count % UINT64_C(1000000) == 0)
+                        LOG("Processing %" PRIu64 "th short cube\n", count);
+
+                if (kv.val < dfsarg->shortdepth) {
+                        coord = kv.key >> (int64_t)(11 - dfsarg->h);
+                        mutex = H48_INDEX(coord, dfsarg->k) % CHUNKS;
+                        pthread_mutex_lock(dfsarg->table_mutex[mutex]);
+                        set_h48_pval(dfsarg->table, coord, dfsarg->k, 0);
+                        pthread_mutex_unlock(dfsarg->table_mutex[mutex]);
+                } else {
+                        dfsarg->cube = invcoord_h48(kv.key, dfsarg->crep, 11);
+                        gendata_h48k2_dfs(dfsarg);
+                }
         }
 
         return NULL;
@@ -524,16 +531,17 @@ STATIC_INLINE void
 gendata_h48k2_mark(cube_t cube, int8_t depth, h48k2_dfs_arg_t *arg)
 {
         uint8_t oldval, newval;
-        int64_t coord, fullcoord;
+        int64_t coord, fullcoord, mutex;
 
         FOREACH_H48SIM(cube, arg->cocsepdata, arg->selfsim,
                 fullcoord = coord_h48(cube, arg->cocsepdata, 11);
                 coord = fullcoord >> (int64_t)(11 - arg->h);
-                pthread_mutex_lock(arg->table_mutex[coord % CHUNKS]);
+                mutex = H48_INDEX(coord, arg->k) % CHUNKS;
+                pthread_mutex_lock(arg->table_mutex[mutex]);
                 oldval = get_h48_pval(arg->table, coord, arg->k);
                 newval = (uint8_t)MAX(depth, 0);
                 set_h48_pval(arg->table, coord, arg->k, MIN(oldval, newval));
-                pthread_mutex_unlock(arg->table_mutex[coord % CHUNKS]);
+                pthread_mutex_unlock(arg->table_mutex[mutex]);
         )
 }
 
diff --git a/src/solvers/h48/h48.h b/src/solvers/h48/h48.h
index ee865d9..2fe9575 100644
--- a/src/solvers/h48/h48.h
+++ b/src/solvers/h48/h48.h
@@ -2,5 +2,6 @@
 #include "map.h"
 #include "gendata_cocsep.h"
 #include "gendata_h48.h"
+#include "stats.h"
 #include "solve.h"
 #include "thread.h"
diff --git a/src/solvers/h48/solve.h b/src/solvers/h48/solve.h
index 4bf55ca..b67aedc 100644
--- a/src/solvers/h48/solve.h
+++ b/src/solvers/h48/solve.h
@@ -16,16 +16,6 @@ typedef struct {
         uint8_t premoves[MAXLEN];
 } dfsarg_solveh48_t;
 
-typedef struct {
-        cube_t cube;
-        int8_t nmoves;
-        int8_t depth;
-        uint8_t moves[MAXLEN];
-        uint32_t *cocsepdata;
-        uint8_t *h48data;
-        char *s;
-} dfsarg_solveh48stats_t;
-
 STATIC uint32_t allowednextmove_h48(uint8_t *, uint8_t, uint32_t);
 
 STATIC void solve_h48_appendsolution(dfsarg_solveh48_t *);
@@ -33,9 +23,6 @@ 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, 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]);
-
 STATIC uint32_t
 allowednextmove_h48(uint8_t *moves, uint8_t n, uint32_t h48branch)
 {
@@ -215,90 +202,3 @@ solve_h48(
 
         return nsols;
 }
-
-/*
-The h48stats solver computes how many moves it takes to solve to
-each of the 12 h48 coordinates, one for each value of h from 0 to 11.
-The solutions array is filled with the length of the solutions. The
-solution array is therefore not a printable string.
-*/
-STATIC int64_t
-solve_h48stats_dfs(dfsarg_solveh48stats_t *arg)
-{
-        const int64_t limit = 11;
-
-        int8_t bound, u;
-        uint8_t m;
-        uint32_t d;
-        int64_t coord, h;
-        dfsarg_solveh48stats_t nextarg;
-
-        /* Check cocsep lower bound (corners only) */
-        bound = get_h48_cdata(arg->cube, arg->cocsepdata, &d);
-        if (bound + arg->nmoves > arg->depth)
-                return 0;
-
-        /* Check h48 lower bound for h=0 (esep, but no eo) */
-        coord = coord_h48_edges(arg->cube, COCLASS(d), TTREP(d), 0);
-        bound = get_h48_bound(arg->cube, d, 0, 4, arg->h48data);
-        if (bound + arg->nmoves > arg->depth)
-                return 0;
-        
-        /* Update all other values, if solved */
-        coord = coord_h48_edges(arg->cube, COCLASS(d), TTREP(d), 11);
-        for (h = 0; h <= limit; h++) {
-                u = coord >> (11-h) == 0 && arg->s[h] == 99;
-                arg->s[h] = u * arg->nmoves + (1-u) * arg->s[h];
-        }
-
-        if (arg->s[limit] != 99)
-                return 0;
-
-        nextarg = *arg;
-        nextarg.nmoves = arg->nmoves + 1;
-        for (m = 0; m < 18; m++) {
-                nextarg.moves[arg->nmoves] = m;
-                if (!allowednextmove(nextarg.moves, nextarg.nmoves)) {
-                        /* If a move is not allowed, neither are its 180
-                         * and 270 degree variations */
-                        m += 2;
-                        continue;
-                }
-                nextarg.cube = move(arg->cube, m);
-                solve_h48stats_dfs(&nextarg);
-        }
-
-        return 0;
-}
-
-STATIC int64_t
-solve_h48stats(
-        cube_t cube,
-        int8_t maxmoves,
-        const void *data,
-        char solutions[static 12]
-)
-{
-        int i;
-        dfsarg_solveh48stats_t arg;
-
-        arg = (dfsarg_solveh48stats_t) {
-                .cube = cube,
-                .cocsepdata = get_cocsepdata_ptr(data),
-                .h48data = get_h48data_ptr(data),
-                .s = solutions
-        };
-
-        for (i = 0; i < 12; i++)
-                solutions[i] = (char)99;
-
-        for (arg.depth = 0;
-             arg.depth <= maxmoves && solutions[11] == 99;
-             arg.depth++)
-        {
-                arg.nmoves = 0;
-                solve_h48stats_dfs(&arg);
-        }
-
-        return 0;
-}
diff --git a/src/solvers/h48/stats.h b/src/solvers/h48/stats.h
new file mode 100644
index 0000000..6e78ab5
--- /dev/null
+++ b/src/solvers/h48/stats.h
@@ -0,0 +1,100 @@
+/*
+The h48stats solver computes how many moves it takes to solve to
+each of the 12 h48 coordinates, one for each value of h from 0 to 11.
+The solutions array is filled with the length of the solutions. The
+solutions array is therefore not a printable string.
+*/
+
+typedef struct {
+        cube_t cube;
+        int8_t nmoves;
+        int8_t depth;
+        uint8_t moves[MAXLEN];
+        uint32_t *cocsepdata;
+        uint8_t *h48data;
+        char *s;
+} dfsarg_solveh48stats_t;
+
+STATIC int64_t solve_h48stats_dfs(dfsarg_solveh48stats_t *);
+STATIC int64_t solve_h48stats(cube_t, int8_t, const void *, char [static 12]);
+
+STATIC int64_t
+solve_h48stats_dfs(dfsarg_solveh48stats_t *arg)
+{
+        const int64_t limit = 11;
+
+        int8_t bound, u;
+        uint8_t m;
+        uint32_t d;
+        int64_t coord, h;
+        dfsarg_solveh48stats_t nextarg;
+
+        /* Check cocsep lower bound (corners only) */
+        bound = get_h48_cdata(arg->cube, arg->cocsepdata, &d);
+        if (bound + arg->nmoves > arg->depth)
+                return 0;
+
+        /* Check h48 lower bound for h=0 (esep, but no eo) */
+        coord = coord_h48_edges(arg->cube, COCLASS(d), TTREP(d), 0);
+        bound = get_h48_bound(arg->cube, d, 0, 4, arg->h48data);
+        if (bound + arg->nmoves > arg->depth)
+                return 0;
+        
+        /* Update all other values, if solved */
+        coord = coord_h48_edges(arg->cube, COCLASS(d), TTREP(d), 11);
+        for (h = 0; h <= limit; h++) {
+                u = coord >> (11-h) == 0 && arg->s[h] == 99;
+                arg->s[h] = u * arg->nmoves + (1-u) * arg->s[h];
+        }
+
+        if (arg->s[limit] != 99)
+                return 0;
+
+        nextarg = *arg;
+        nextarg.nmoves = arg->nmoves + 1;
+        for (m = 0; m < 18; m++) {
+                nextarg.moves[arg->nmoves] = m;
+                if (!allowednextmove(nextarg.moves, nextarg.nmoves)) {
+                        /* If a move is not allowed, neither are its 180
+                         * and 270 degree variations */
+                        m += 2;
+                        continue;
+                }
+                nextarg.cube = move(arg->cube, m);
+                solve_h48stats_dfs(&nextarg);
+        }
+
+        return 0;
+}
+
+STATIC int64_t
+solve_h48stats(
+        cube_t cube,
+        int8_t maxmoves,
+        const void *data,
+        char solutions[static 12]
+)
+{
+        int i;
+        dfsarg_solveh48stats_t arg;
+
+        arg = (dfsarg_solveh48stats_t) {
+                .cube = cube,
+                .cocsepdata = get_cocsepdata_ptr(data),
+                .h48data = get_h48data_ptr(data),
+                .s = solutions
+        };
+
+        for (i = 0; i < 12; i++)
+                solutions[i] = (char)99;
+
+        for (arg.depth = 0;
+             arg.depth <= maxmoves && solutions[11] == 99;
+             arg.depth++)
+        {
+                arg.nmoves = 0;
+                solve_h48stats_dfs(&arg);
+        }
+
+        return 0;
+}
diff --git a/tools/0022_gendata_h48h2k2/gendata_h48h2k2.c b/tools/0022_gendata_h48h2k2/gendata_h48h2k2.c
new file mode 100644
index 0000000..f437e98
--- /dev/null
+++ b/tools/0022_gendata_h48h2k2/gendata_h48h2k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "2;2;20", "tables/h48h2k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 2, k = 2");
+
+        return 0;
+}
diff --git a/tools/0032_gendata_h48h3k2/gendata_h48h3k2.c b/tools/0032_gendata_h48h3k2/gendata_h48h3k2.c
new file mode 100644
index 0000000..2e0eab5
--- /dev/null
+++ b/tools/0032_gendata_h48h3k2/gendata_h48h3k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "3;2;20", "tables/h48h3k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 3, k = 2");
+
+        return 0;
+}
diff --git a/tools/0042_gendata_h48h4k2/gendata_h48h4k2.c b/tools/0042_gendata_h48h4k2/gendata_h48h4k2.c
new file mode 100644
index 0000000..868c360
--- /dev/null
+++ b/tools/0042_gendata_h48h4k2/gendata_h48h4k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "4;2;20", "tables/h48h4k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 4, k = 2");
+
+        return 0;
+}
diff --git a/tools/0052_gendata_h48h5k2/gendata_h48h5k2.c b/tools/0052_gendata_h48h5k2/gendata_h48h5k2.c
new file mode 100644
index 0000000..d292d49
--- /dev/null
+++ b/tools/0052_gendata_h48h5k2/gendata_h48h5k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "5;2;20", "tables/h48h5k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 5, k = 2");
+
+        return 0;
+}
diff --git a/tools/0062_gendata_h48h6k2/gendata_h48h6k2.c b/tools/0062_gendata_h48h6k2/gendata_h48h6k2.c
new file mode 100644
index 0000000..910d514
--- /dev/null
+++ b/tools/0062_gendata_h48h6k2/gendata_h48h6k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "6;2;20", "tables/h48h6k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 6, k = 2");
+
+        return 0;
+}
diff --git a/tools/0072_gendata_h48h7k2/gendata_h48h7k2.c b/tools/0072_gendata_h48h7k2/gendata_h48h7k2.c
new file mode 100644
index 0000000..b803328
--- /dev/null
+++ b/tools/0072_gendata_h48h7k2/gendata_h48h7k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "7;2;20", "tables/h48h7k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 7, k = 2");
+
+        return 0;
+}
diff --git a/tools/0082_gendata_h48h8k2/gendata_h48h8k2.c b/tools/0082_gendata_h48h8k2/gendata_h48h8k2.c
new file mode 100644
index 0000000..52c377a
--- /dev/null
+++ b/tools/0082_gendata_h48h8k2/gendata_h48h8k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "8;2;20", "tables/h48h8k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 8, k = 2");
+
+        return 0;
+}
diff --git a/tools/0092_gendata_h48h9k2/gendata_h48h9k2.c b/tools/0092_gendata_h48h9k2/gendata_h48h9k2.c
new file mode 100644
index 0000000..5d3e34a
--- /dev/null
+++ b/tools/0092_gendata_h48h9k2/gendata_h48h9k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "9;2;20", "tables/h48h9k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 9, k = 2");
+
+        return 0;
+}
diff --git a/tools/0102_gendata_h48h10k2/gendata_h48h10k2.c b/tools/0102_gendata_h48h10k2/gendata_h48h10k2.c
new file mode 100644
index 0000000..5e8fbb0
--- /dev/null
+++ b/tools/0102_gendata_h48h10k2/gendata_h48h10k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "10;2;20", "tables/h48h10k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 10, k = 2");
+
+        return 0;
+}
diff --git a/tools/0112_gendata_h48h11k2/gendata_h48h11k2.c b/tools/0112_gendata_h48h11k2/gendata_h48h11k2.c
new file mode 100644
index 0000000..00c0747
--- /dev/null
+++ b/tools/0112_gendata_h48h11k2/gendata_h48h11k2.c
@@ -0,0 +1,21 @@
+#include "../tool.h"
+
+uint64_t expected[21] = {
+        /* Base value is 8 */
+        [0] = 0, /* Unknown */
+        [1] = 0, /* Unknown */
+        [2] = 0, /* Unknown */
+        [3] = 0, /* Unknown */
+};
+
+void run(void) {
+        gendata_run("h48", "11;2;20", "tables/h48h11k2", expected);
+}
+
+int main(void) {
+        nissy_setlogger(log_stderr);
+
+        timerun(run, "benchmark gendata_h48 h = 11, k = 2");
+
+        return 0;
+}