Fix duplicate solutions, overflow in maxsols and improve symmetry reduction for H48.

This commit fixes two bugs:
  - A bug that caused duplicates solutions for symmetric scrambles.
  - An overflow in the maxsols parameter for the H48 solver, which
    caused it to find much fewer solutions than existed.

Moreover, the H48 solvers has been improved by reducing by symmetry not
only from the starting position, but also up to the first 4 moves.

5 files changed, 203 insertions, 118 deletions

diff --git a/src/solvers/coord/multisolve.h b/src/solvers/coord/multisolve.h
index f3589e8..a45bd6a 100644
--- a/src/solvers/coord/multisolve.h
+++ b/src/solvers/coord/multisolve.h
@@ -9,6 +9,7 @@ typedef struct {
         uint8_t target_depth;
         solution_moves_t *solution_moves;
         solution_settings_t *solution_settings;
+        uint64_t tmask;
         solution_list_t *solution_list;
         multicoord_t *mcoord;
         const unsigned char *coord_data[MAX_MULTICOORD_NCOORDS];
@@ -87,7 +88,7 @@ solve_multicoord_dfs(dfsarg_solve_multicoord_t arg[static 1])
         /* All coordinates are solved */
         if (!multicoord_solution_admissible(arg))
                 return 0;
-        return appendsolution(arg->solution_moves,
+        return appendsolution(arg->solution_moves, 1, &arg->tmask,
             arg->solution_settings, arg->solution_list);
 
 solve_multicoord_dfs_notsolved:
@@ -208,7 +209,6 @@ solve_multicoord(
         solution_moves_reset(&solution_moves);
 
         solution_settings = (solution_settings_t) {
-                .tmask = TM_SINGLE(inverse_trans(trans)),
                 .unniss = false,
                 .maxmoves = maxmoves,
                 .maxsolutions = maxsolutions,
@@ -222,6 +222,7 @@ solve_multicoord(
                 .mcoord = mcoord,
                 .solution_moves = &solution_moves,
                 .solution_settings = &solution_settings,
+                .tmask = TM_SINGLE(inverse_trans(trans)),
                 .solution_list = &solution_list,
         };
 
@@ -258,8 +259,8 @@ solve_multicoord(
         }
 
         /* All coordinates are solved */
-        if (minmoves == 0 && !appendsolution(&solution_moves,
-            &solution_settings, &solution_list))
+        if (minmoves == 0 && !appendsolution(&solution_moves, 1,
+            &arg.tmask, &solution_settings, &solution_list))
                 goto solve_multicoord_error_buffer;
         goto solve_multicoord_done;
 
diff --git a/src/solvers/coord/solve.h b/src/solvers/coord/solve.h
index 54309b1..9ea6d1a 100644
--- a/src/solvers/coord/solve.h
+++ b/src/solvers/coord/solve.h
@@ -3,6 +3,7 @@ typedef struct {
         cube_t inverse;
         uint8_t target_depth;
         solution_moves_t *solution_moves;
+        uint64_t tmask;
         solution_settings_t *solution_settings;
         solution_list_t *solution_list;
         uint8_t nissflag;
@@ -163,7 +164,7 @@ solve_coord_dfs(dfsarg_solve_coord_t arg[static 1])
         if (coord_is_solved(arg->coord, coord, arg->coord_data)) {
                 if (!coord_solution_admissible(arg))
                         return 0;
-                return appendsolution(arg->solution_moves,
+                return appendsolution(arg->solution_moves, 1, &arg->tmask,
                     arg->solution_settings, arg->solution_list);
         }
 
@@ -339,7 +340,6 @@ solve_coord(
         solution_moves_reset(&solution_moves);
 
         solution_settings = (solution_settings_t) {
-                .tmask = TM_SINGLE(inverse_trans(trans)),
                 .unniss = false,
                 .maxmoves = maxmoves,
                 .maxsolutions = maxsolutions,
@@ -355,14 +355,15 @@ solve_coord(
                 .ptable = ptable,
                 .solution_moves = &solution_moves,
                 .solution_settings = &solution_settings,
+                .tmask = TM_SINGLE(inverse_trans(trans)),
                 .solution_list = &solution_list,
                 .nissflag = nissflag,
         };
 
         i = coord->coord(c, coord_data);
         if (coord_is_solved(coord, i, coord_data)) {
-                if (minmoves == 0 && !appendsolution(&solution_moves,
-                    &solution_settings, &solution_list))
+                if (minmoves == 0 && !appendsolution(&solution_moves, 1,
+                    &arg.tmask, &solution_settings, &solution_list))
                                 goto solve_coord_error_buffer;
                 goto solve_coord_done;
         }
diff --git a/src/solvers/h48/solve.h b/src/solvers/h48/solve.h
index bf10723..ad66fd4 100644
--- a/src/solvers/h48/solve.h
+++ b/src/solvers/h48/solve.h
@@ -13,6 +13,7 @@ typedef struct {
         cube_t cube;
         uint8_t moves[H48_STARTING_MOVES];
         int64_t rank;
+        uint64_t tmask[H48_STARTING_MOVES];
 } solve_h48_task_t;
 
 typedef struct {
@@ -22,6 +23,7 @@ typedef struct {
         int8_t target_depth;
         solution_moves_t *solution_moves;
         solution_settings_t *solution_settings;
+        const uint64_t *tmask;
         solution_list_t *solution_list;
         int8_t lb_normal;
         int8_t lb_inverse;
@@ -55,6 +57,7 @@ typedef struct {
         int8_t minmoves;
         int8_t maxmoves;
         int8_t *shortest_sol;
+        uint64_t tmask[H48_STARTING_MOVES];
 } dfsarg_solve_h48_maketasks_t;
 
 STATIC long long solve_h48_dispatch(oriented_cube_t, const char *, unsigned,
@@ -69,7 +72,7 @@ STATIC void *solve_h48_runthread(void *);
 STATIC int64_t solve_h48_dfs(dfsarg_solve_h48_t [static 1]);
 STATIC void solve_h48_log_solutions(solution_list_t [static 1], size_t);
 STATIC int solve_h48_compare_tasks(const void *, const void *);
-STATIC int64_t solve_h48(oriented_cube_t, uint8_t, uint8_t, uint8_t, uint8_t,
+STATIC int64_t solve_h48(oriented_cube_t, uint8_t, uint8_t, uint64_t, uint8_t,
     uint8_t, uint64_t, const unsigned char *, size_t, char *,
     long long [static NISSY_SIZE_SOLVE_STATS], int (*)(void *), void *);
 
@@ -208,8 +211,8 @@ solve_h48_dfs(dfsarg_solve_h48_t arg[static 1])
                 if (arg->target_depth != nm)
                         return 0;
                 wrapthread_mutex_lock(arg->solutions_mutex);
-                ret = appendsolution(arg->solution_moves,
-                    arg->solution_settings, arg->solution_list);
+                ret = appendsolution(arg->solution_moves, H48_STARTING_MOVES,
+                    arg->tmask, arg->solution_settings, arg->solution_list);
                 wrapthread_mutex_unlock(arg->solutions_mutex);
                 return ret;
         }
@@ -313,6 +316,7 @@ solve_h48_runthread(void *arg)
                 dfsarg->use_lb_inverse = false;
                 dfsarg->movemask_normal = MM18_ALLMOVES;
                 dfsarg->movemask_inverse = MM18_ALLMOVES;
+                dfsarg->tmask = dfsarg->tasks[i].tmask;
 
                 solve_h48_dfs(dfsarg);
 
@@ -341,7 +345,7 @@ solve_h48_runthread_end:
 STATIC int64_t
 solve_h48_maketasks(
         dfsarg_solve_h48_t solve_arg[static 1],
-        dfsarg_solve_h48_maketasks_t maketasks_arg[static 1],
+        dfsarg_solve_h48_maketasks_t mtarg[static 1],
         solve_h48_task_t tasks[static H48_STARTING_CUBES],
         int ntasks[static 1]
 )
@@ -353,59 +357,60 @@ solve_h48_maketasks(
         cube_t backup_cube;
         solution_moves_t moves;
 
-        if (equal(maketasks_arg->cube, SOLVED_CUBE)) {
-                if (maketasks_arg->nmoves > maketasks_arg->maxmoves ||
-                    maketasks_arg->nmoves < maketasks_arg->minmoves ||
+        if (equal(mtarg->cube, SOLVED_CUBE)) {
+                if (mtarg->nmoves > mtarg->maxmoves ||
+                    mtarg->nmoves < mtarg->minmoves ||
                     solutions_done(solve_arg->solution_list,
-                        solve_arg->solution_settings, maketasks_arg->nmoves))
+                        solve_arg->solution_settings, mtarg->nmoves))
                         return NISSY_OK;
 
                 solution_moves_reset(&moves);
-                moves.nmoves = maketasks_arg->nmoves;
-                memcpy(moves.moves,
-                    maketasks_arg->moves, maketasks_arg->nmoves);
+                moves.nmoves = mtarg->nmoves;
+                memcpy(moves.moves, mtarg->moves, mtarg->nmoves);
 
-                appret = appendsolution(&moves, solve_arg->solution_settings,
-                    solve_arg->solution_list);
+                appret = appendsolution(&moves, mtarg->nmoves, mtarg->tmask,
+                    solve_arg->solution_settings, solve_arg->solution_list);
                 return appret < 0 ? appret : NISSY_OK;
         }
 
-        if (maketasks_arg->nmoves == H48_STARTING_MOVES) {
-                tasks[*ntasks].cube = maketasks_arg->cube;
-                memcpy(tasks[*ntasks].moves,
-                    maketasks_arg->moves, H48_STARTING_MOVES);
+        if (mtarg->nmoves == H48_STARTING_MOVES) {
+                tasks[*ntasks].cube = mtarg->cube;
+                memcpy(tasks[*ntasks].moves, mtarg->moves,
+                    H48_STARTING_MOVES * sizeof(uint8_t));
+                memcpy(tasks[*ntasks].tmask, mtarg->tmask,
+                    H48_STARTING_MOVES * sizeof(uint64_t));
                 (*ntasks)++;
                 return NISSY_OK;
         }
 
-        if (maketasks_arg->nmoves == 0) {
+        if (mtarg->nmoves == 0) {
                 mm = MM18_ALLMOVES;
         } else {
-                m = maketasks_arg->moves[maketasks_arg->nmoves-1];
+                m = mtarg->moves[mtarg->nmoves-1];
                 mm = allowedmask[movebase(m)];
         }
 
-        maketasks_arg->nmoves++;
-        backup_cube = maketasks_arg->cube;
+        mtarg->tmask[mtarg->nmoves] = symmetry_mask(mtarg->cube);
+
+        mtarg->nmoves++;
+        backup_cube = mtarg->cube;
         for (m = 0; m < 18; m++) {
                 if (!(mm & MM_SINGLE(m)))
                         continue;
-                maketasks_arg->moves[maketasks_arg->nmoves-1] = m;
-                maketasks_arg->cube = move(backup_cube, m);
-                r = solve_h48_maketasks(
-                    solve_arg, maketasks_arg, tasks, ntasks);
+
+                mtarg->moves[mtarg->nmoves-1] = m;
+                mtarg->cube = move(backup_cube, m);
+                r = solve_h48_maketasks(solve_arg, mtarg, tasks, ntasks);
                 if (r < 0)
                         return r;
 
                 /* Avoid symmetry-equivalent moves from the starting cube */
-                if (maketasks_arg->nmoves == 1)
-                        for (t = 0; t < NTRANS; t++)
-                                if (solve_arg->solution_settings->tmask &
-                                    TM_SINGLE(t))
-                                        mm &= ~MM_SINGLE(transform_move(m, t));
+                for (t = 0; t < NTRANS; t++)
+                        if (mtarg->tmask[mtarg->nmoves-1] & TM_SINGLE(t))
+                                mm &= ~MM_SINGLE(transform_move(m, t));
         }
-        maketasks_arg->nmoves--;
-        maketasks_arg->cube = backup_cube;
+        mtarg->nmoves--;
+        mtarg->cube = backup_cube;
 
         return NISSY_OK;
 }
@@ -441,7 +446,7 @@ solve_h48(
         oriented_cube_t oc,
         uint8_t minmoves,
         uint8_t maxmoves,
-        uint8_t maxsolutions,
+        uint64_t maxsolutions,
         uint8_t optimal,
         uint8_t threads,
         uint64_t data_size,
@@ -460,7 +465,7 @@ solve_h48(
         int8_t d;
         dfsarg_solve_h48_t arg[THREADS];
         solve_h48_task_t tasks[H48_STARTING_CUBES];
-        dfsarg_solve_h48_maketasks_t maketasks_arg;
+        dfsarg_solve_h48_maketasks_t mtarg;
         long double fallback_rate, lookups_per_node;
         uint64_t offset;
         uint64_t nodes_visited, table_lookups, table_fallbacks;
@@ -508,7 +513,6 @@ solve_h48(
         fallback2 = h48data + offset;
 
         settings = (solution_settings_t) {
-                .tmask = symmetry_mask(oc.cube),
                 .unniss = true,
                 .maxmoves = maxmoves,
                 .maxsolutions = maxsolutions,
@@ -543,14 +547,14 @@ solve_h48(
 
         wrapthread_mutex_init(&solutions_mutex, NULL);
 
-        maketasks_arg = (dfsarg_solve_h48_maketasks_t) {
+        mtarg = (dfsarg_solve_h48_maketasks_t) {
                 .cube = oc.cube,
                 .nmoves = 0,
                 .minmoves = minmoves,
                 .maxmoves = maxmoves,
         };
         ntasks = 0;
-        solve_h48_maketasks(&arg[0], &maketasks_arg, tasks, &ntasks);
+        solve_h48_maketasks(&arg[0], &mtarg, tasks, &ntasks);
         if (ntasks < 0)
                 goto solve_h48_error_solutions_buffer;
         if (solutions_done(&sollist, &settings,
diff --git a/src/solvers/solutions.h b/src/solvers/solutions.h
index 9f209d1..d92d5ad 100644
--- a/src/solvers/solutions.h
+++ b/src/solvers/solutions.h
@@ -1,17 +1,23 @@
 STATIC void solution_moves_reset(solution_moves_t [static 1]);
-STATIC void solution_moves_transform(solution_moves_t [static 1], uint8_t);
+STATIC void solution_moves_transform(solution_moves_t [static 1], size_t,
+    uint8_t);
 STATIC void solution_moves_reorient(solution_moves_t [static 1], uint8_t);
 STATIC bool solution_list_init(solution_list_t [static 1], size_t, char *);
 STATIC bool solution_moves_equal(
     const solution_moves_t [static 1], const solution_moves_t [static 1]);
-STATIC bool solution_moves_is_duplicate(size_t, const solution_moves_t *);
+STATIC bool last_solution_is_duplicate(const solution_list_t [static 1]);
 STATIC bool appendchar(solution_list_t [static 1], char);
 STATIC bool appendnormal(
     const solution_moves_t [static 1], solution_list_t [static 1]);
 STATIC bool appendinverse(
     const solution_moves_t [static 1], solution_list_t [static 1]);
+STATIC void appendsolution_dfs(const solution_moves_t [static 1], size_t,
+    const uint64_t *, size_t, uint8_t *, const solution_settings_t [static 1],
+    solution_list_t [static 1],
+    solution_moves_t [static NTRANS * SOLUTION_MAXLEN], int64_t [static 1]);
 STATIC int64_t appendsolution(const solution_moves_t [static 1],
-    const solution_settings_t [static 1], solution_list_t [static 1]);
+    size_t, const uint64_t *, const solution_settings_t [static 1],
+    solution_list_t [static 1]);
 STATIC bool solutions_done(const solution_list_t [static 1],
     const solution_settings_t [static 1], int8_t depth);
 
@@ -23,11 +29,11 @@ solution_moves_reset(solution_moves_t sol[static 1])
 }
 
 STATIC void
-solution_moves_transform(solution_moves_t moves[static 1], uint8_t t)
+solution_moves_transform(solution_moves_t moves[static 1], size_t z, uint8_t t)
 {
         uint8_t i;
 
-        for (i = 0; i < moves->nmoves; i++)
+        for (i = z; i < moves->nmoves; i++)
                 moves->moves[i] = transform_move(moves->moves[i], t);
 
         for (i = 0; i < moves->npremoves; i++)
@@ -87,13 +93,27 @@ solution_moves_equal(
 }
 
 STATIC bool
-solution_moves_is_duplicate(size_t n, const solution_moves_t *s)
+last_solution_is_duplicate(const solution_list_t l[static 1])
 {
-        size_t i;
+        size_t i, j;
+
+        if (l->nsols == 1)
+                return false;
 
-        for (i = 0; i < n; i++)
-                if (solution_moves_equal(&s[i], &s[n]))
-                        return true;
+        /* We assume the list is newline-terminated */
+        j = l->used-2;
+        while (true) {
+                for ( ; l->buf[j] != '\n'; j--)
+                        if (j == 0) return false;
+                j--;
+                for (i = l->used-2; l->buf[i] == l->buf[j]; i--, j--) {
+                        if (l->buf[i-1] == '\n') {
+                                if (l->buf[j-1] == '\n' || j == 0)
+                                        return true;
+                                else break;
+                        }
+                }
+        }
 
         return false;
 }
@@ -150,97 +170,157 @@ appendinverse(
         return appendchar(list, ')');
 }
 
-STATIC int64_t
-appendsolution(
+STATIC void
+appendsolution_dfs(
         const solution_moves_t moves[static 1],
+        size_t ntmask,
+        const uint64_t *tmask,
+        size_t itm,
+        uint8_t *tt,
         const solution_settings_t settings[static 1],
-        solution_list_t list[static 1]
+        solution_list_t list[static 1],
+        solution_moves_t tsol[static NTRANS * SOLUTION_MAXLEN],
+        int64_t r[static 1]
 )
 {
-        int64_t r;
-        int i;
-        uint8_t t;
-        solution_moves_t tsol[NTRANS];
+        /*
+        The logic here is quit complex because we have to address H48
+        solutions that may be reduced by symmetry in the first few moves.
+        */
 
-        if (moves->nmoves + moves->npremoves > SOLUTION_MAXLEN)
-                goto appendsolution_error_solution_length;
+        size_t i, last_start;
+        uint8_t t;
+        solution_moves_t moves_copy;
 
-        for (
-            t = 0, r = 0;
-            t < NTRANS && list->nsols < settings->maxsolutions;
-            t++
-        ) {
-                if (!(settings->tmask & TM_SINGLE(t)))
-                        continue;
+        if (list->nsols >= settings->maxsolutions)
+                return;
 
-                tsol[r] = *moves;
-                if (settings->unniss) {
-                        tsol[r].nmoves += moves->npremoves;
-                        tsol[r].npremoves = 0;
-                        for (i = moves->npremoves-1; i >= 0; i--)
-                                tsol[r].moves[tsol[r].nmoves - i - 1] =
-                                    inverse_move(moves->premoves[i]);
+        if (ntmask == itm) {
+                tsol[*r] = *moves;
 
-                        /*
-                        This is a bit ugly: we have to sort now and then again
-                        later, because the allowedmoves check would fail with
-                        improperly sorted parallel moves, but then transforming
-                        could swap the pairs the wrong way around.
-                        */
-                        sortparallel_moves(tsol[r].nmoves, tsol[r].moves);
+                for (i = ntmask; i > 0; i--)
+                        solution_moves_transform(&tsol[*r], i-1, tt[i-1]);
 
-                        /* Check if unnissed premoves cancel with normal. */
-                        if (!allowedmoves(tsol[r].nmoves, tsol[r].moves))
-                                continue;
-                }
-                solution_moves_transform(&tsol[r], t);
-                solution_moves_reorient(&tsol[r], settings->orientation);
-                sortparallel_moves(tsol[r].nmoves, tsol[r].moves);
-                sortparallel_moves(tsol[r].npremoves, tsol[r].premoves);
+                solution_moves_reorient(&tsol[*r], settings->orientation);
+                sortparallel_moves(tsol[*r].nmoves, tsol[*r].moves);
+                sortparallel_moves(tsol[*r].npremoves, tsol[*r].premoves);
 
-                /* Skip duplicates that may appear after transforming */
-                if (solution_moves_is_duplicate(r, tsol))
-                        continue;
+                last_start = list->used;
 
                 /* Append first the moves on the side that has more */
                 /* E.g. write (U L F) B instead of B (U L F) */
-                if (tsol[r].nmoves >= tsol[r].npremoves) {
-                        if (!appendnormal(&tsol[r], list))
-                                goto appendsolution_error_buffer;
+                if (tsol[*r].nmoves >= tsol[*r].npremoves) {
+                        if (!appendnormal(&tsol[*r], list))
+                                goto appendsolution_dfs_error_buffer;
 
-                        if (tsol[r].nmoves > 0 && tsol[r].npremoves > 0)
+                        if (tsol[*r].nmoves > 0 && tsol[*r].npremoves > 0)
                                 if (!appendchar(list, ' '))
-                                        return false;
+                                        goto appendsolution_dfs_error_buffer;
 
-                        if (!appendinverse(&tsol[r], list))
-                                goto appendsolution_error_buffer;
+                        if (!appendinverse(&tsol[*r], list))
+                                goto appendsolution_dfs_error_buffer;
                 } else {
-                        if (!appendinverse(&tsol[r], list))
-                                goto appendsolution_error_buffer;
+                        if (!appendinverse(&tsol[*r], list))
+                                goto appendsolution_dfs_error_buffer;
 
-                        if (tsol[r].nmoves > 0 && tsol[r].npremoves > 0)
+                        if (tsol[*r].nmoves > 0 && tsol[*r].npremoves > 0)
                                 if (!appendchar(list, ' '))
-                                        return false;
+                                        goto appendsolution_dfs_error_buffer;
 
-                        if (!appendnormal(&tsol[r], list))
-                                goto appendsolution_error_buffer;
+                        if (!appendnormal(&tsol[*r], list))
+                                goto appendsolution_dfs_error_buffer;
                 }
 
                 if (!appendchar(list, '\n'))
-                        goto appendsolution_error_buffer;
-
+                        goto appendsolution_dfs_error_buffer;
                 ++list->nsols;
+
+                /*
+                Normaly, it would be enough to check for duplicates in the
+                current "pack" of transformation-equivalent solutions.
+                However, in rare cases, the H48 solver may produce equivalent
+                "packs" of solutions. It would be more elegant to filter out
+                the corresponding tasks in solve_h48_maketasks(), but doing so
+                is not trivial. In the end, duplicate solutions are never
+                desirable, so we might as well do this clean up here.
+                */
+                if (last_solution_is_duplicate(list)) {
+                        --list->nsols;
+                        list->used = last_start;
+                        return;
+                }
+
                 list->shortest_sol = MIN(
-                    list->shortest_sol, tsol[r].nmoves + tsol[r].npremoves);
-                r++;
+                    list->shortest_sol, tsol[*r].nmoves + tsol[*r].npremoves);
+                (*r)++;
+        } else {
+                for (t = 0; t < NTRANS; t++) {
+                        if (!(tmask[itm] & TM_SINGLE(t)))
+                                continue;
+                        moves_copy = *moves;
+                        tt[itm] = t;
+                        appendsolution_dfs(&moves_copy, ntmask, tmask,
+                            itm+1, tt, settings, list, tsol, r);
+                        if (*r < 0)
+                                return;
+                }
         }
 
-        list->buf[list->used] = '\0';
-        return r;
+        return;
 
-appendsolution_error_buffer:
+appendsolution_dfs_error_buffer:
         list->buf[0] = '\0';
-        return NISSY_ERROR_BUFFER_SIZE;
+        *r = NISSY_ERROR_BUFFER_SIZE;
+        return;
+}
+
+STATIC int64_t
+appendsolution(
+        const solution_moves_t moves[static 1],
+        size_t ntmask,
+        const uint64_t *tmask,
+        const solution_settings_t settings[static 1],
+        solution_list_t list[static 1]
+)
+{
+        int64_t r;
+        int i;
+        uint8_t tt[SOLUTION_MAXLEN];
+        solution_moves_t moves_copy, tsol[NTRANS * SOLUTION_MAXLEN];
+
+        if (moves->nmoves + moves->npremoves > SOLUTION_MAXLEN)
+                goto appendsolution_error_solution_length;
+
+        moves_copy = *moves;
+        if (settings->unniss) {
+                moves_copy.nmoves += moves->npremoves;
+                moves_copy.npremoves = 0;
+                for (i = moves->npremoves-1; i >= 0; i--)
+                        moves_copy.moves[moves_copy.nmoves - i - 1] =
+                            inverse_move(moves->premoves[i]);
+
+                /*
+                This is a bit ugly: we have to sort now and then again
+                later, because the allowedmoves check would fail with
+                improperly sorted parallel moves, but then transforming
+                could swap the pairs the wrong way around.
+                */
+                sortparallel_moves(moves_copy.nmoves, moves_copy.moves);
+
+                /* Check if unnissed premoves cancel with normal. */
+                if (!allowedmoves(moves_copy.nmoves, moves_copy.moves))
+                        return 0;
+        }
+
+        r = 0;
+        memset(tt, TRANS_UFr, SOLUTION_MAXLEN);
+        appendsolution_dfs(
+            &moves_copy, ntmask, tmask, 0, tt, settings, list, tsol, &r);
+        if (r < 0)
+                return r;
+
+        list->buf[list->used] = '\0';
+        return r;
 
 appendsolution_error_solution_length:
         list->buf[0] = '\0';
diff --git a/src/solvers/solutions_types_macros.h b/src/solvers/solutions_types_macros.h
index c8efc0b..4727e5a 100644
--- a/src/solvers/solutions_types_macros.h
+++ b/src/solvers/solutions_types_macros.h
@@ -8,7 +8,6 @@ typedef struct {
 } solution_moves_t;
 
 typedef struct {
-        uint64_t tmask;
         bool unniss;
         uint8_t maxmoves;
         uint64_t maxsolutions;