16 files changed, 213 insertions, 51 deletions

diff --git a/configure.sh b/configure.sh
index e31e650..4a60ed4 100755
--- a/configure.sh
+++ b/configure.sh
@@ -85,6 +85,7 @@ validatethreads
 validatearch
 
 STD="-std=c11"
+POSIX="-D_POSIX_C_SOURCE=199309L"
 WFLAGS="-pedantic -Wall -Wextra"
 WNOFLAGS="-Wno-unused-parameter -Wno-unused-function -Wno-unknown-pragmas"
 WNOFLAGS="$WNOFLAGS -Wno-unused-command-line-argument"
@@ -99,8 +100,8 @@ if [ -n "$SANITIZE" ]; then
 fi
 LIBS="-lpthread"
 
-CFLAGS="$STD $LIBS $WFLAGS $WNOFLAGS $AVX -O3 -fPIC -D$ARCH"
-DBGFLAGS="$STD $LIBS $WFLAGS $WNOFLAGS $SAN $AVX -g3 -DDEBUG -fPIC -D$ARCH"
+CFLAGS="$STD $POSIX $LIBS $WFLAGS $WNOFLAGS $AVX -O3 -fPIC -D$ARCH"
+DBGFLAGS="$STD $POSIX $LIBS $WFLAGS $WNOFLAGS $SAN $AVX -g3 -DDEBUG -fPIC -D$ARCH"
 WASMFLAGS="$STD $LIBS $WFLAGS $WNOFLAGS -O3 -fPIC"
 MACROS="-DTHREADS=$THREADS"
 
diff --git a/cpp/examples/solve_h48h3k2.cpp b/cpp/examples/solve_h48h3k2.cpp
index f7ba235..f0d6f2f 100644
--- a/cpp/examples/solve_h48h3k2.cpp
+++ b/cpp/examples/solve_h48h3k2.cpp
@@ -68,7 +68,7 @@ int main() {
 
         // Solve
         auto solve_result = h48h3k2.solve(c, nissy::nissflag::NORMAL,
-            0, maxmoves, 1, 20, 8);
+            0, maxmoves, 1, 20, 8, NULL, NULL);
 
         // Write the result
         if (!solve_result.err.ok()) {
diff --git a/cpp/nissy.cpp b/cpp/nissy.cpp
index 118a072..2faea6f 100644
--- a/cpp/nissy.cpp
+++ b/cpp/nissy.cpp
@@ -20,7 +20,8 @@ extern "C" {
         long long nissy_checkdata(unsigned long long, const unsigned char *);
         long long nissy_solve(const char *, const char *, unsigned, unsigned,
             unsigned, unsigned, unsigned, unsigned, unsigned long long,
-            const unsigned char *, unsigned, char *, long long *);
+            const unsigned char *, unsigned, char *, long long *,
+            int (*)(void *), void *);
         long long nissy_countmoves(const char *);
         long long nissy_setlogger(void (*)(const char *, void *), void *);
 }
@@ -47,6 +48,10 @@ namespace nissy {
         const error error::OPTIONS{-80};
         const error error::UNKNOWN{-999};
 
+        const status status::run{0};
+        const status status::stop{1};
+        const status status::pause{2};
+
         namespace size {
                 constexpr size_t CUBE = 22;
                 constexpr size_t TRANSFORMATION = 12;
@@ -154,7 +159,8 @@ namespace nissy {
         solver::solve_result
         solver::solve(const cube& cube, nissflag niss, unsigned minmoves,
             unsigned maxmoves, unsigned maxsols, unsigned optimal,
-            unsigned threads)
+            unsigned threads, int (*poll_status)(void *),
+            void *poll_status_data)
         {
                 solver::solve_result result;
 
@@ -171,7 +177,8 @@ namespace nissy {
                     name.c_str(), niss.value, minmoves, maxmoves, maxsols,
                     optimal, threads, data.size(),
                     reinterpret_cast<const unsigned char *>(data.data()), len,
-                    csols.data(), result.stats.data());
+                    csols.data(), result.stats.data(), poll_status,
+                    poll_status_data);
                 result.err = error{err};
 
                 if (err < 0)
diff --git a/cpp/nissy.h b/cpp/nissy.h
index 4fa98ad..41d3876 100644
--- a/cpp/nissy.h
+++ b/cpp/nissy.h
@@ -46,6 +46,15 @@ namespace nissy {
                 static const error UNKNOWN;
         };
 
+        class status {
+        public:
+                int value;
+
+                static const status run;
+                static const status stop;
+                static const status pause;
+        };
+
         class cube {
         public:
                 cube();
@@ -86,7 +95,8 @@ namespace nissy {
                 void unload_data();
                 solve_result solve(const cube&, nissflag, unsigned minmoves,
                     unsigned maxmoves, unsigned maxsols, unsigned optimal,
-                    unsigned threads);
+                    unsigned threads, int (*poll_status)(void *),
+                    void *poll_status_data);
 
                 static std::variant<solver, error> get(const std::string&);
         private:
diff --git a/python/nissy_module.c b/python/nissy_module.c
index bf5a71a..069dea0 100644
--- a/python/nissy_module.c
+++ b/python/nissy_module.c
@@ -300,7 +300,7 @@ solve(PyObject *self, PyObject *args)
         result = nissy_solve(cube, solver, nissflag, minmoves, maxmoves,
             maxsolutions, optimal, threads, data->ob_alloc,
             (unsigned char *)data->ob_bytes, MAX_SOLUTIONS_SIZE, solutions,
-            stats);
+            stats, NULL, NULL);
         Py_END_ALLOW_THREADS
 
         if(!check_error(result)) {
@@ -350,9 +350,9 @@ static PyMethodDef nissy_methods[] = {
         { "getcube", getcube, METH_VARARGS, getcube_doc },
         { "solverinfo", solverinfo, METH_VARARGS, solverinfo_doc },
         { "gendata", gendata, METH_VARARGS, gendata_doc },
-        { "checkdata", checkdata, METH_VARARGS, checkdata_doc },
+        { "checkdata", _checkdata, METH_VARARGS, checkdata_doc },
         { "solve", solve, METH_VARARGS, solve_doc },
-        { "countmoves", countmoves, METH_VARARGS, countmoves_doc },
+        { "countmoves", _countmoves, METH_VARARGS, countmoves_doc },
         { NULL, NULL, 0, NULL }
 };
 
diff --git a/shell/shell.c b/shell/shell.c
index 3ee69c4..1fa854f 100644
--- a/shell/shell.c
+++ b/shell/shell.c
@@ -435,7 +435,7 @@ solve_exec(args_t *args)
         ret = nissy_solve(
             args->cube, args->str_solver, nissflag, args->minmoves,
             args->maxmoves, args->maxsolutions, args->optimal, args->threads,
-            size, buf, SOLUTIONS_BUFFER_SIZE, solutions, stats);
+            size, buf, SOLUTIONS_BUFFER_SIZE, solutions, stats, NULL, NULL);
 
         free(buf);
 
diff --git a/src/nissy.c b/src/nissy.c
index 2dd5a41..acf6ebe 100644
--- a/src/nissy.c
+++ b/src/nissy.c
@@ -460,7 +460,9 @@ nissy_solve(
         const unsigned char data[data_size],
         unsigned sols_size,
         char sols[sols_size],
-        long long stats[static NISSY_SIZE_SOLVE_STATS]
+        long long stats[static NISSY_SIZE_SOLVE_STATS],
+        int (*poll_status)(void *),
+        void *poll_status_data
 )
 {
         oriented_cube_t oc;
@@ -475,14 +477,23 @@ nissy_solve(
 
         oc = readcube(cube);
 
-/* TODO: solve should handle oriented cubes */
-
         if (!isconsistent(oc)) {
                 LOG("[solve] Error: cube is invalid\n");
                 return NISSY_ERROR_INVALID_CUBE;
         }
 
-/* TODO: checks for minmoves, maxmoves, nissflag */
+        if (maxmoves > 20) {
+                LOG("[solve] 'maxmoves' larger than 20 not supported yet, "
+                    "setting it to 20\n");
+                maxmoves = 20;
+        }
+
+        if (minmoves > maxmoves) {
+                LOG("[solve] value provided for 'minmoves' (%u) is larger "
+                    "than that provided for 'maxmoves' (%u), setting "
+                    "'minmoves' to %u\n", minmoves, maxmoves, maxmoves);
+                minmoves = maxmoves;
+        }
 
         if (maxsols == 0) {
                 LOG("[solve] 'maxsols' is 0, returning no solution\n");
@@ -505,11 +516,12 @@ nissy_solve(
                 if (parse_ret != NISSY_OK)
                         return parse_ret;
                 return solve_h48(oc, minmoves, maxmoves, maxsols,
-                    optimal, t, data_size, data, sols_size, sols, stats);
+                    optimal, t, data_size, data, sols_size, sols, stats,
+                    poll_status, poll_status_data);
         } else if (!strncmp(solver, "coord_", 6)) {
                 return solve_coord_dispatch(oc, solver + 6, nissflag,
                     minmoves, maxmoves, maxsols, optimal, t, data_size, data,
-                    sols_size, sols);
+                    sols_size, sols, poll_status, poll_status_data);
         } else {
                 LOG("[solve] Error: unknown solver '%s'\n", solver);
                 return NISSY_ERROR_INVALID_SOLVER;
diff --git a/src/nissy.h b/src/nissy.h
index 5800490..2fa4a75 100644
--- a/src/nissy.h
+++ b/src/nissy.h
@@ -37,6 +37,11 @@ for example 'rotation UF' or 'mirrored BL'.
 #define NISSY_NISSFLAG_ALL \
     (NISSY_NISSFLAG_NORMAL | NISSY_NISSFLAG_INVERSE | NISSY_NISSFLAG_MIXED)
 
+/* Status for stopping / pausing / resuming a solver */
+#define NISSY_STATUS_RUN    0
+#define NISSY_STATUS_STOP   1
+#define NISSY_STATUS_PAUSE  2
+
 /* The solved cube */
 #define NISSY_SOLVED_CUBE "ABCDEFGH=ABCDEFGHIJKL=A"
 
@@ -296,24 +301,32 @@ nissy_checkdata(
 Solve the given cube using the given solver and options.
 
 Parameters:
-   cube      - The cube to solver.
-   solver    - The name of the solver.
-   nissflag  - The flags for NISS (linear, inverse, mixed, or combinations).
-   minmoves  - The minimum number of moves for a solution.
-   maxmoves  - The maximum number of moves for a solution.
-   maxsols   - The maximum number of solutions.
-   optimal   - The maximum number of moves above the optimal solution length.
-   threads   - The number of threads to use. Must be less than or equalt to
-               the value of the compile-time constant THREADS. If set to 0,
-               the default value THREADS will be used.
-   data_size - The size of the data buffer.
-   data      - The data for the solver. Can be computed with gendata.
-               This buffer must have 8-byte alignment.
-   sols_size - The size of the solutions buffer.
-   sols      - The return parameter for the solutions. The solutions are
-               separated by a '\n' (newline) and a '\0' (NULL character)
-               terminates the list.
-   stats     - An array to store some statistics about the solve.
+   cube             - The cube to solver.
+   solver           - The name of the solver.
+   nissflag         - The flags for NISS (linear, inverse, mixed, or
+                      combinations; see the constants at the top of this file).
+   minmoves         - The minimum number of moves for a solution.
+   maxmoves         - The maximum number of moves for a solution.
+   maxsols          - The maximum number of solutions.
+   optimal          - The maximum number of moves above the optimal solution.
+   threads          - The number of threads to use. Must be less than or equal
+                      to the value of the compile-time constant THREADS. If set
+                      to 0, the default value THREADS will be used.
+   data_size        - The size of the data buffer.
+   data             - The data for the solver. Can be computed with gendata.
+                      This buffer must have 8-byte alignment.
+   sols_size        - The size of the solutions buffer.
+   sols             - The return parameter for the solutions. The solutions are
+                      separated by a '\n' (newline) and a '\0' (NULL character)
+                      terminates the list.
+   stats            - An array to store some statistics about the solve.
+   poll_status      - A callback function that should return the current
+                      requested status for the solver (e.g. run, stop, pause,
+                      resume; see the constants at the top of this file). The
+                      way this status is polled and honored is solver-specific.
+                      If this parameter is NULL, the status will always assumed
+                      to be "run".
+   poll_status_data - Auxiliary data for the poll_status callback function.
 
 Return values:
    NISSY_OK                    - Cube solved succesfully.
@@ -340,7 +353,9 @@ nissy_solve(
         const unsigned char data[data_size],
         unsigned sols_size,
         char sols[sols_size],
-        long long stats[static NISSY_SIZE_SOLVE_STATS]
+        long long stats[static NISSY_SIZE_SOLVE_STATS],
+        int (*poll_status)(void *),
+        void *poll_status_data
 );
 
 /*
diff --git a/src/solvers/coord/solve.h b/src/solvers/coord/solve.h
index 48cc704..8eb3e9d 100644
--- a/src/solvers/coord/solve.h
+++ b/src/solvers/coord/solve.h
@@ -14,10 +14,10 @@ typedef struct {
 
 STATIC int64_t solve_coord(oriented_cube_t, coord_t [static 1], uint8_t,
     uint8_t, uint8_t, uint8_t, uint64_t, uint8_t, uint8_t, uint64_t,
-    const unsigned char *, size_t n, char [n]);
+    const unsigned char *, size_t n, char [n], int (*)(void *), void *);
 STATIC int64_t solve_coord_dispatch(oriented_cube_t, const char *, uint8_t,
     uint8_t, uint8_t, uint64_t, uint8_t, uint8_t, uint64_t,
-    const unsigned char *, size_t n, char [n]);
+    const unsigned char *, size_t n, char [n], int (*)(void *), void *);
 STATIC bool coord_solution_admissible(const dfsarg_solve_coord_t [static 1]);
 STATIC bool solve_coord_dfs_stop(const dfsarg_solve_coord_t [static 1]);
 STATIC bool coord_continue_onnormal(const dfsarg_solve_coord_t [static 1]);
@@ -211,7 +211,9 @@ solve_coord_dispatch(
         uint64_t data_size,
         const unsigned char *data,
         size_t solutions_size,
-        char sols[solutions_size]
+        char sols[solutions_size],
+        int (*poll_status)(void *),
+        void *poll_status_data
 )
 {
         coord_t *coord;
@@ -233,7 +235,7 @@ solve_coord_dispatch(
 
         return solve_coord(oc, coord, axis, nissflag, minmoves, maxmoves,
             maxsolutions, optimal, threads, data_size, data,
-            solutions_size, sols);
+            solutions_size, sols, poll_status, poll_status_data);
 }
 
 STATIC int64_t
@@ -250,7 +252,9 @@ solve_coord(
         uint64_t data_size,
         const unsigned char *data,
         size_t solutions_size,
-        char sols[solutions_size]
+        char sols[solutions_size],
+        int (*poll_status)(void *),
+        void *poll_status_data
 )
 {
         int8_t d;
diff --git a/src/solvers/h48/solve.h b/src/solvers/h48/solve.h
index e3ef9b9..f2967ed 100644
--- a/src/solvers/h48/solve.h
+++ b/src/solvers/h48/solve.h
@@ -35,6 +35,10 @@ typedef struct {
         solve_h48_task_t *tasks;
         int thread_id;
         pthread_mutex_t *solutions_mutex;
+        int (*poll_status)(void *);
+        void *poll_status_data;
+        _Atomic bool cancelled;
+        _Atomic bool cantsleep;
 } dfsarg_solve_h48_t;
 
 typedef struct {
@@ -50,11 +54,12 @@ STATIC_INLINE bool solve_h48_stop(dfsarg_solve_h48_t [static 1]);
 STATIC int64_t solve_h48_maketasks(
     dfsarg_solve_h48_t [static 1], dfsarg_solve_h48_maketasks_t [static 1],
     solve_h48_task_t [static STARTING_CUBES], int [static 1]);
+STATIC bool solve_h48_runthread_continue(dfsarg_solve_h48_t *);
 STATIC void *solve_h48_runthread(void *);
 STATIC int64_t solve_h48_dfs(dfsarg_solve_h48_t [static 1]);
 STATIC int64_t solve_h48(oriented_cube_t, uint8_t, uint8_t, uint8_t, uint8_t,
     uint8_t, uint64_t, const unsigned char *, size_t n, char [n],
-    long long [static NISSY_SIZE_SOLVE_STATS]);
+    long long [static NISSY_SIZE_SOLVE_STATS], int (*)(void *), void *);
 
 STATIC_INLINE bool
 solve_h48_stop(dfsarg_solve_h48_t arg[static 1])
@@ -232,16 +237,42 @@ solve_h48_dfs(dfsarg_solve_h48_t arg[static 1])
         return ret;
 }
 
+STATIC bool
+solve_h48_runthread_continue(dfsarg_solve_h48_t *arg)
+{
+        int status;
+
+        for (status = NISSY_STATUS_PAUSE; status == NISSY_STATUS_PAUSE; ) {
+                status = arg->poll_status == NULL ? NISSY_STATUS_RUN :
+                    arg->poll_status(arg->poll_status_data);
+                msleep(500);
+        }
+
+        return status == NISSY_STATUS_RUN;
+}
+
 STATIC void *
 solve_h48_runthread(void *arg)
 {
-        int i, j;
+        int i, j, status;
         solve_h48_task_t task;
         dfsarg_solve_h48_t *dfsarg;
 
         dfsarg = (dfsarg_solve_h48_t *)arg;
 
         for (i = dfsarg->thread_id; i < dfsarg->ntasks; i += dfsarg->threads) {
+                status = dfsarg->poll_status == NULL ? NISSY_STATUS_RUN :
+                    dfsarg->poll_status(dfsarg->poll_status_data);
+                switch (status) {
+                case NISSY_STATUS_STOP:
+                        goto solve_h48_runthread_cancel;
+                case NISSY_STATUS_PAUSE:
+                        if (!NISSY_CANSLEEP)
+                                goto solve_h48_runthread_cantsleep;
+                        if (!solve_h48_runthread_continue(dfsarg))
+                                goto solve_h48_runthread_cancel;
+                }
+
                 task = dfsarg->tasks[i];
 
                 solution_moves_reset(dfsarg->solution_moves);
@@ -265,6 +296,12 @@ solve_h48_runthread(void *arg)
         }
 
         return NULL;
+
+solve_h48_runthread_cantsleep:
+        dfsarg->cantsleep = true;
+solve_h48_runthread_cancel:
+        dfsarg->cancelled = true;
+        return NULL;
 }
 
 STATIC int64_t
@@ -351,9 +388,12 @@ solve_h48(
         const unsigned char *data,
         size_t solutions_size,
         char solutions[solutions_size],
-        long long stats[static NISSY_SIZE_SOLVE_STATS]
+        long long stats[static NISSY_SIZE_SOLVE_STATS],
+        int (*poll_status)(void *),
+        void *poll_status_data
 )
 {
+        bool anycancelled, anycantsleep;
         int i, ntasks, eoesep_table_index;
         int8_t d;
         dfsarg_solve_h48_t arg[THREADS];
@@ -434,6 +474,10 @@ solve_h48(
                         .threads = threads,
                         .thread_id = i,
                         .solutions_mutex = &solutions_mutex,
+                        .poll_status = poll_status,
+                        .poll_status_data = poll_status_data,
+                        .cancelled = false,
+                        .cantsleep = false,
                 };
 
         }
@@ -460,9 +504,10 @@ solve_h48(
 
         LOG("[H48 solve] Prepared %d tasks\n", ntasks);
 
+        anycancelled = anycantsleep = false;
         for (
             d = MAX(minmoves, STARTING_MOVES + 1);
-            !solutions_done(&sollist, &settings, d);
+            !(solutions_done(&sollist, &settings, d) || anycancelled);
             d++
         ) {
                 if (d >= 15)
@@ -474,8 +519,22 @@ solve_h48(
                         pthread_create(
                             &thread[i], NULL, solve_h48_runthread, &arg[i]);
                 }
-                for (i = 0; i < threads; i++)
+                for (i = 0; i < threads; i++) {
                         pthread_join(thread[i], NULL);
+                        anycancelled = anycancelled || arg[i].cancelled;
+                        anycantsleep = anycantsleep || arg[i].cantsleep;
+                }
+        }
+
+        if (anycantsleep) {
+                LOG("[H48 solve] Received pause request, but this feature is "
+                    "not available on this system. "
+                    "Taking it as a stop request.\n");
+        }
+
+        if (anycancelled) {
+                LOG("[H48 solve] Received stop request, ending solution "
+                    "search early.\n");
         }
 
 solve_h48_done:
diff --git a/src/utils/sleep.h b/src/utils/sleep.h
new file mode 100644
index 0000000..d618e9b
--- /dev/null
+++ b/src/utils/sleep.h
@@ -0,0 +1,48 @@
+STATIC void msleep(int);
+
+#if defined(WIN32)
+
+#define NISSY_CANSLEEP true
+
+STATIC void
+msleep(int milliseconds)
+{
+        Sleep(milliseconds);
+}
+
+#elif defined(__wasm__)
+
+#include <emscripten.h>
+
+#define NISSY_CANSLEEP true
+
+STATIC void
+msleep(int milliseconds)
+{
+        emscripten_sleep(milliseconds);
+}
+
+#elif defined(__unix__)
+
+#include <time.h>
+
+#define NISSY_CANSLEEP true
+
+STATIC void
+msleep(int milliseconds)
+{
+        struct timespec t;
+        t.tv_sec = milliseconds / 1000;
+        t.tv_nsec = (milliseconds % 1000) * 1000000;
+        nanosleep(&t, NULL);
+}
+
+#else
+
+#define NISSY_CANSLEEP false
+STATIC void
+msleep(int milliseconds)
+{
+}
+
+#endif
diff --git a/src/utils/utils.h b/src/utils/utils.h
index ce4355e..d14b285 100644
--- a/src/utils/utils.h
+++ b/src/utils/utils.h
@@ -1,3 +1,4 @@
 #include "dbg_log.h"
 #include "constants.h"
 #include "math.h"
+#include "sleep.h"
diff --git a/tools/300_solve_small/solve_small.c b/tools/300_solve_small/solve_small.c
index dcd47c1..83a712a 100644
--- a/tools/300_solve_small/solve_small.c
+++ b/tools/300_solve_small/solve_small.c
@@ -37,7 +37,8 @@ void run(void) {
                         continue;
                 }
                 n = nissy_solve(cube, solver, NISSY_NISSFLAG_NORMAL,
-                    0, 20, 1, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats);
+                    0, 20, 1, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats,
+                    NULL, NULL);
                 if (n == 0)
                         printf("No solution found\n");
                 else
diff --git a/tools/301_solve_file/solve_file.c b/tools/301_solve_file/solve_file.c
index d9084fd..be4d1f5 100644
--- a/tools/301_solve_file/solve_file.c
+++ b/tools/301_solve_file/solve_file.c
@@ -24,7 +24,8 @@ void run(void) {
                         continue;
                 }
                 nsols = nissy_solve(cube, solver, NISSY_NISSFLAG_NORMAL,
-                    0, 20, 1, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats);
+                    0, 20, 1, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats,
+                    NULL, NULL);
                 if (nsols == 0)
                         printf("No solution found\n");
                 else
diff --git a/tools/302_solve_multisol/solve_multisol.c b/tools/302_solve_multisol/solve_multisol.c
index a2896a9..8f04b5f 100644
--- a/tools/302_solve_multisol/solve_multisol.c
+++ b/tools/302_solve_multisol/solve_multisol.c
@@ -30,7 +30,8 @@ void run(void) {
                         continue;
                 }
                 n = nissy_solve(cube, solver, NISSY_NISSFLAG_NORMAL,
-                    0, 20, nsol, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats);
+                    0, 20, nsol, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats,
+                    NULL, NULL);
                 if (n == 0)
                         printf("No solution found\n");
                 else
diff --git a/tools/400_solvetest/solve_test.c b/tools/400_solvetest/solve_test.c
index 1bfe851..73e6e8e 100644
--- a/tools/400_solvetest/solve_test.c
+++ b/tools/400_solvetest/solve_test.c
@@ -57,7 +57,8 @@ void run(void) {
                         continue;
                 }
                 n = nissy_solve(cube, solver, NISSY_NISSFLAG_NORMAL,
-                    0, 20, 1, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats);
+                    0, 20, 1, -1, 0, size, buf, SOL_BUFFER_LEN, sol, stats,
+                    NULL, NULL);
                 if (n == 0) {
                         printf("Error: no solution\n");
                         return;
@@ -78,7 +79,8 @@ void run(void) {
                         continue;
                 }
                 n = nissy_solve(cube, solver, NISSY_NISSFLAG_NORMAL,
-                    0, 20, 100, 0, 0, size, buf, SOL_BUFFER_LEN, sol, stats);
+                    0, 20, 100, 0, 0, size, buf, SOL_BUFFER_LEN, sol, stats,
+                    NULL, NULL);
                 if (check_all(sol, s[i].solutions)) {
                         printf("All solutions are correct\n");
                 } else {