7 files changed, 110 insertions, 175 deletions

diff --git a/src/core/cube.h b/src/core/cube.h
index a3c3e14..49d868c 100644
--- a/src/core/cube.h
+++ b/src/core/cube.h
@@ -4,7 +4,7 @@ STATIC bool isconsistent(cube_t);
 STATIC bool issolvable(cube_t);
 STATIC bool issolved(cube_t);
 STATIC bool iserror(cube_t);
-STATIC void getcube_fix(int64_t *, int64_t *, int64_t *, int64_t *);
+STATIC void getcube_fix(long long *, long long *, long long *, long long *);
 STATIC cube_t getcube(int64_t, int64_t, int64_t, int64_t);
 
 /* This is used only in tests, use SOLVED_CUBE directly everywhere else */
@@ -128,7 +128,7 @@ iserror(cube_t cube)
 }
 
 STATIC void
-getcube_fix(int64_t *ep, int64_t *eo, int64_t *cp, int64_t *co)
+getcube_fix(long long *ep, long long *eo, long long *cp, long long *co)
 {
         uint8_t e[12], c[8], coarr[8];
 
diff --git a/src/core/io_moves.h b/src/core/io_moves.h
index be43568..806887b 100644
--- a/src/core/io_moves.h
+++ b/src/core/io_moves.h
@@ -43,6 +43,7 @@ writemoves(uint8_t *m, int n, uint64_t buf_size, char *buf)
 {
         int i;
         uint64_t len;
+        int64_t written;
         const char *s;
         char *b;
 
@@ -51,16 +52,16 @@ writemoves(uint8_t *m, int n, uint64_t buf_size, char *buf)
                 return NISSY_ERROR_BUFFER_SIZE;
         }
 
-        for (i = 0, b = buf; i < n; i++, b++, buf_size--) {
+        for (i = 0, b = buf, written = 0; i < n; i++, b++, written++) {
                 s = movestr[m[i]];
                 len = strlen(s);
-                if (len >= buf_size) {
+                if (len + written >= buf_size) {
                         LOG("Error: the given buffer is too small for "
                              "writing the given moves.\n");
                         goto writemoves_error;
                 }
                 memcpy(b, s, len);
-                buf_size -= len;
+                written += len;
                 b += len;       
                 *b = ' ';
         }
@@ -69,7 +70,7 @@ writemoves(uint8_t *m, int n, uint64_t buf_size, char *buf)
                 b--; /* Remove last space */
         *b = '\0';
 
-        return buf_size;
+        return written;
 
 writemoves_error:
         *buf = '\0';
diff --git a/src/core/moves.h b/src/core/moves.h
index 28abc7f..d07bc19 100644
--- a/src/core/moves.h
+++ b/src/core/moves.h
@@ -15,7 +15,6 @@ STATIC void invertmoves(uint8_t *, uint8_t, uint8_t *);
 
 STATIC int readmoves(const char *, int, uint8_t *);
 STATIC cube_t applymoves(cube_t, const char *);
-STATIC cube_t frommoves(const char *);
 
 #define FOREACH_READMOVE(ARG_BUF, ARG_MOVE, ARG_C, ARG_MAX, \
         RET_ERROR, ARG_ACTION) \
@@ -246,9 +245,3 @@ applymoves(cube_t cube, const char *buf)
 
         return cube;
 }
-
-STATIC cube_t
-frommoves(const char *buf)
-{
-        return applymoves(SOLVED_CUBE, buf);
-}
diff --git a/src/nissy.c b/src/nissy.c
index 6b083e0..fe2747b 100644
--- a/src/nissy.c
+++ b/src/nissy.c
@@ -12,7 +12,7 @@
 #include "solvers/solvers.h"
 
 int parse_h48_solver(const char *, uint8_t [static 1], uint8_t [static 1]);
-STATIC int64_t write_result(cube_t, char [static NISSY_SIZE_B32]);
+STATIC long long write_result(cube_t, char [static NISSY_SIZE_B32]);
 STATIC bool distribution_equal(const uint64_t [static INFO_DISTRIBUTION_LEN],
     const uint64_t [static INFO_DISTRIBUTION_LEN], uint8_t);
 STATIC bool checkdata(const char *, const tableinfo_t *);
@@ -20,7 +20,7 @@ STATIC bool checkdata(const char *, const tableinfo_t *);
 #define GETCUBE_OPTIONS(S, F) { .option = S, .fix = F }
 struct {
         char *option;
-        void (*fix)(int64_t *, int64_t *, int64_t *, int64_t *);
+        void (*fix)(long long *, long long *, long long *, long long *);
 } getcube_options[] = {
         GETCUBE_OPTIONS("fix", getcube_fix),
         GETCUBE_OPTIONS(NULL, NULL)
@@ -105,7 +105,7 @@ distribution_equal(
         return wrong == 0;
 }
 
-STATIC int64_t
+STATIC long long
 write_result(cube_t cube, char result[static NISSY_SIZE_B32])
 {
         writecube("B32", cube, NISSY_SIZE_B32, result);
@@ -118,7 +118,7 @@ write_result(cube_t cube, char result[static NISSY_SIZE_B32])
         return NISSY_OK;
 }
 
-int64_t
+long long
 nissy_compose(
         const char cube[static NISSY_SIZE_B32],
         const char permutation[static NISSY_SIZE_B32],
@@ -126,7 +126,7 @@ nissy_compose(
 )
 {
         cube_t c, p, res;
-        int64_t err;
+        long long err;
 
         c = readcube("B32", cube);
 
@@ -159,14 +159,14 @@ nissy_compose_error:
         return err;
 }
 
-int64_t
+long long
 nissy_inverse(
         const char cube[static NISSY_SIZE_B32],
         char result[static NISSY_SIZE_B32]
 )
 {
         cube_t c, res;
-        int64_t err;
+        long long err;
 
         c = readcube("B32", cube);
 
@@ -191,7 +191,7 @@ nissy_inverse_error:
         return err;
 }
 
-int64_t
+long long
 nissy_applymoves(
         const char cube[static NISSY_SIZE_B32],
         const char *moves,
@@ -199,7 +199,7 @@ nissy_applymoves(
 )
 {
         cube_t c, res;
-        int64_t err;
+        long long err;
 
         if (moves == NULL) {
                 LOG("Error: 'moves' argument is NULL\n");
@@ -230,7 +230,7 @@ nissy_applymoves_error:
         return err;
 }
 
-int64_t
+long long
 nissy_applytrans(
         const char cube[static NISSY_SIZE_B32],
         const char transformation[static NISSY_SIZE_TRANSFORMATION],
@@ -238,7 +238,7 @@ nissy_applytrans(
 )
 {
         cube_t c, res;
-        int64_t err;
+        long long err;
 
         c = readcube("B32", cube);
 
@@ -263,47 +263,17 @@ nissy_applytrans_error:
         return err;
 }
 
-int64_t
-nissy_frommoves(
-        const char *moves,
-        char result[static NISSY_SIZE_B32]
-)
-{
-        cube_t res;
-        int64_t err;
-
-        if (moves == NULL) {
-                LOG("Error: 'moves' argument is NULL\n");
-                err = NISSY_ERROR_NULL_POINTER;
-                goto nissy_frommoves_error;
-        }
-
-        res = applymoves(SOLVED_CUBE, moves);
-
-        if (!isconsistent(res)) {
-                /* Assume we got a reasonable error message from applymoves */
-                err = NISSY_ERROR_INVALID_MOVES;
-                goto nissy_frommoves_error;
-        }
-
-        return write_result(res, result);
-
-nissy_frommoves_error:
-        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
-        return err;
-}
-
-int64_t
+long long
 nissy_convert(
         const char *format_in,
         const char *format_out,
         const char *cube_string,
-        uint64_t result_size,
+        unsigned result_size,
         char result[result_size]
 )
 {
         cube_t c;
-        int64_t err;
+        long long err;
 
         if (format_in == NULL) {
                 LOG("Error: 'format_in' argument is NULL\n");
@@ -337,12 +307,12 @@ nissy_convert_error:
         return err;
 }
 
-int64_t
+long long
 nissy_getcube(
-        int64_t ep,
-        int64_t eo,
-        int64_t cp,
-        int64_t co,
+        long long ep,
+        long long eo,
+        long long cp,
+        long long co,
         const char *options,
         char result[static NISSY_SIZE_B32]
 )
@@ -371,7 +341,7 @@ nissy_getcube(
         return write_result(c, result);
 }
 
-int64_t
+long long
 nissy_datasize(
         const char *solver
 )
@@ -385,7 +355,7 @@ nissy_datasize(
         return nissy_gendata(solver, 0, NULL);
 }
 
-int64_t
+long long
 nissy_datainfo(
         uint64_t data_size,
         const char data[data_size],
@@ -394,7 +364,7 @@ nissy_datainfo(
 {
         uint8_t i;
         tableinfo_t info;
-        int64_t ret;
+        long long ret;
 
         ret = readtableinfo(data_size, data, &info);
         if (ret != 0)
@@ -434,10 +404,10 @@ nissy_datainfo(
         return NISSY_OK;
 }
 
-int64_t
+long long
 nissy_gendata(
         const char *solver,
-        uint64_t data_size,
+        unsigned long long data_size,
         char data[data_size]
 )
 {
@@ -463,9 +433,9 @@ nissy_gendata(
         }
 }
 
-int64_t
+long long
 nissy_checkdata(
-        uint64_t data_size,
+        unsigned long long data_size,
         const char data[data_size]
 )
 {
@@ -488,18 +458,18 @@ nissy_checkdata(
         return NISSY_OK;
 }
 
-int64_t
+long long
 nissy_solve(
         const char cube[static NISSY_SIZE_B32],
         const char *solver, 
-        uint8_t nissflag,
-        int8_t minmoves,
-        int8_t maxmoves,
-        int64_t maxsols,
-        int8_t optimal,
-        uint64_t data_size,
+        unsigned nissflag,
+        unsigned minmoves,
+        unsigned maxmoves,
+        unsigned maxsols,
+        int optimal,
+        unsigned long long data_size,
         const char data[data_size],
-        uint64_t sols_size,
+        unsigned sols_size,
         char sols[sols_size]
 )
 {
@@ -524,21 +494,6 @@ nissy_solve(
                 return NISSY_ERROR_UNSOLVABLE_CUBE;
         }
 
-        if (minmoves < 0) {
-                LOG("solve: 'minmoves' is negative, setting it to 0\n");
-                minmoves = 0;
-        }
-
-        if (maxmoves < 0) {
-                LOG("solve: 'maxmoves' is negative, setting it to 20\n");
-                maxmoves = 20;
-        }
-
-        if (maxsols < 0) {
-                LOG("solve: 'maxsols' is negative, stopping\n");
-                return NISSY_ERROR_OPTIONS;
-        }
-
         if (maxsols == 0) {
                 LOG("solve: 'maxsols' is 0, returning no solution\n");
                 return 0;
@@ -565,7 +520,7 @@ nissy_solve(
         }
 }
 
-int64_t
+long long
 nissy_setlogger(
         void (*log)(const char *, ...)
 )
diff --git a/src/nissy.h b/src/nissy.h
index 6d78778..8f4f363 100644
--- a/src/nissy.h
+++ b/src/nissy.h
@@ -1,13 +1,6 @@
 /*
 This is libnissy (temporarily also known as h48), a Rubik's cube library.
 
-If you include this file, you should also use the following includes:
-
-#include <inttypes.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <string.h>
-
 All the functions return 0 or a positive integer in case of success and
 a negative integer in case of error, unless otherwise specified. See at
 the bottom of this file for the list of error codes and their meaning.
@@ -24,20 +17,29 @@ A transformation must be given in the format
 for example 'rotation UF' or 'mirrored BL'.
 */
 
+
+/* Constants *****************************************************************/
+
 /* Some constants for size for I/O buffers */
-#define NISSY_SIZE_B32            UINT64_C(22)
-#define NISSY_SIZE_H48            UINT64_C(88)
-#define NISSY_SIZE_TRANSFORMATION UINT64_C(12)
+#define NISSY_SIZE_B32            22U
+#define NISSY_SIZE_H48            88U
+#define NISSY_SIZE_TRANSFORMATION 12U
 
 /* Flags for NISS options */
-#define NISSY_NISSFLAG_NORMAL  UINT8_C(1)
-#define NISSY_NISSFLAG_INVERSE UINT8_C(2)
-#define NISSY_NISSFLAG_MIXED   UINT8_C(4)
-#define NISSY_NISSFLAG_LINEAR  \
+#define NISSY_NISSFLAG_NORMAL  1U
+#define NISSY_NISSFLAG_INVERSE 2U
+#define NISSY_NISSFLAG_MIXED   4U
+#define NISSY_NISSFLAG_LINEAR \
     (NISSY_NISSFLAG_NORMAL | NISSY_NISSFLAG_INVERSE)
-#define NISSY_NISSFLAG_ALL     \
+#define NISSY_NISSFLAG_ALL \
     (NISSY_NISSFLAG_NORMAL | NISSY_NISSFLAG_INVERSE | NISSY_NISSFLAG_MIXED)
 
+/* The solved cube in B32 format */
+#define NISSY_SOLVED_CUBE "ABCDEFGH=ABCDEFGHIJKL"
+
+
+/* Library functions *********************************************************/
+
 /*
 Apply the secod argument as a permutation on the first argument.
 
@@ -56,7 +58,7 @@ Return values:
    NISSY_ERROR_INVALID_CUBE  - At least one of the given cubes is invalid.
    NISSY_ERROR_UNKNOWN       - An unknown error occurred.
 */
-int64_t nissy_compose(
+long long nissy_compose(
         const char cube[static NISSY_SIZE_B32],
         const char permutation[static NISSY_SIZE_B32],
         char result[static NISSY_SIZE_B32]
@@ -77,7 +79,7 @@ Return values:
    NISSY_ERROR_INVALID_CUBE  - The given cube is invalid.
    NISSY_ERROR_UNKNOWN       - An unknown error occurred.
 */
-int64_t nissy_inverse(
+long long nissy_inverse(
         const char cube[static NISSY_SIZE_B32],
         char result[static NISSY_SIZE_B32]
 );
@@ -99,7 +101,7 @@ Return values:
    NISSY_ERROR_INVALID_MOVES - The given moves are invalid.
    NISSY_ERROR_NULL_POINTER  - The 'moves' argument is NULL.
 */
-int64_t nissy_applymoves(
+long long nissy_applymoves(
         const char cube[static NISSY_SIZE_B32],
         const char *moves,
         char result[static NISSY_SIZE_B32]
@@ -120,33 +122,13 @@ Return values:
    NISSY_ERROR_INVALID_CUBE  - The given cube is invalid.
    NISSY_ERROR_INVALID_TRANS - The given transformation is invalid.
 */
-int64_t nissy_applytrans(
+long long nissy_applytrans(
         const char cube[static NISSY_SIZE_B32],
         const char transformation[static NISSY_SIZE_TRANSFORMATION],
         char result[static NISSY_SIZE_B32]
 );
 
 /*
-Apply the given moves to the solved cube.
-
-Parameters:
-   moves  - The moves to be applied to the solved cube. Must be a
-            NULL-terminated string.
-   result - Return parameter for the resulting cube, in B32 format.
-
-Return values:
-   NISSY_OK                  - The moves were performed succesfully.
-   NISSY_WARNING_UNSOLVABLE  - The resulting cube is not solvable. This is
-                               probably due to an unknown internal error.
-   NISSY_ERROR_INVALID_MOVES - The given moves are invalid.
-   NISSY_ERROR_NULL_POINTER  - The 'moves' argument is NULL.
-*/
-int64_t nissy_frommoves(
-        const char *moves,
-        char result[static NISSY_SIZE_B32]
-);
-
-/*
 Convert the given cube between the two given formats.
 
 Parameters:
@@ -165,11 +147,11 @@ Return values:
    NISSY_ERROR_NULL_POINTER   - At least one of 'format_in', 'format_out' or
                                 'cube_string' arguments is NULL.
 */
-int64_t nissy_convert(
+long long nissy_convert(
         const char *format_in,
         const char *format_out,
         const char *cube_string,
-        uint64_t result_size,
+        unsigned result_size,
         char result[result_size]
 );
 
@@ -192,11 +174,11 @@ Return values:
    NISSY_WARNING_UNSOLVABLE - The resulting cube is unsolvable.
    NISSY_ERROR_OPTIONS      - One or more of the given parameters is invalid.
 */
-int64_t nissy_getcube(
-        int64_t ep,
-        int64_t eo,
-        int64_t cp,
-        int64_t co,
+long long nissy_getcube(
+        long long ep,
+        long long eo,
+        long long cp,
+        long long co,
         const char *options,
         char result[static NISSY_SIZE_B32]
 );
@@ -214,7 +196,7 @@ Return values:
    NISSY_ERROR_UNKNOWN        - An unknown error occurred.
    Any value >= 0             - The size of the data, in bytes.
 */
-int64_t nissy_datasize(
+long long nissy_datasize(
         const char *solver
 );
 
@@ -233,9 +215,9 @@ Return values:
    NISSY_ERROR_UNKNOWN        - An error occurred while generating the data.
    Any value >= 0             - The size of the data, in bytes.
 */
-int64_t nissy_gendata(
+long long nissy_gendata(
         const char *solver,
-        uint64_t data_size,
+        unsigned long long data_size,
         char data[data_size]
 );
 
@@ -250,8 +232,8 @@ Return values:
    NISSY_OK         - The data is valid.
    NISSY_ERROR_DATA - The data is invalid.
 */
-int64_t nissy_checkdata(
-        uint64_t data_size,
+long long nissy_checkdata(
+        unsigned long long data_size,
         const char data[data_size]
 );
 
@@ -284,17 +266,17 @@ Return values:
    NISSY_ERROR_NULL_POINTER    - The 'solver' argument is null.
    Any value >= 0              - The number of solutions found.
 */
-int64_t nissy_solve(
+long long nissy_solve(
         const char cube[static NISSY_SIZE_B32],
         const char *solver, 
-        uint8_t nissflag,
-        int8_t minmoves,
-        int8_t maxmoves,
-        int64_t maxsolutions,
-        int8_t optimal,
-        uint64_t data_size,
+        unsigned nissflag,
+        unsigned minmoves,
+        unsigned maxmoves,
+        unsigned maxsolutions,
+        int optimal,
+        unsigned long long data_size,
         const char data[data_size],
-        uint64_t sols_size,
+        unsigned sols_size,
         char sols[sols_size]
 );
 
@@ -308,18 +290,18 @@ Return values:
    NISSY_OK - Logger set succesfully. No warning or error is goind to be given
               if the logger is NULL or invalid.
 */
-int64_t nissy_setlogger(
+long long nissy_setlogger(
         void (*logger_function)(const char *, ...)
 );
 
 
-/* Error codes */
+/* Error codes ***************************************************************/
 
 /*
 The value NISSY_OK denotes a success. If returned by solve, it means
 that no solution has been found.
 */
-#define NISSY_OK                     INT64_C(0)
+#define NISSY_OK 0LL
 
 /*
 The value NISSY_WARNING_UNSOLVABLE is a warning. It means that the
@@ -327,44 +309,44 @@ operation was completed succesfully, but the resulting cube is in an
 unsolvable state. This could be intended, for example if the user has
 provided an unsolvable cube as input.
 */
-#define NISSY_WARNING_UNSOLVABLE     INT64_C(-1)
+#define NISSY_WARNING_UNSOLVABLE -1LL
 
 /*
 The value NISSY_ERROR_INVALID_CUBE means that the provided cube is
 invalid. It could be written in an unknown format, or in a format
 different from what specified, or simply ill-formed.
 */
-#define NISSY_ERROR_INVALID_CUBE     INT64_C(-10)
+#define NISSY_ERROR_INVALID_CUBE -10LL
 
 /*
 The value NISSY_ERROR_UNSOLVABLE_CUBE means that the provided cube is
 in an unsolvable state.
 */
-#define NISSY_ERROR_UNSOLVABLE_CUBE  INT64_C(-11)
+#define NISSY_ERROR_UNSOLVABLE_CUBE -11LL
 
 /*
 The value NISSY_ERROR_INVALID_MOVES means that the given moves are
 invalid.
 */
-#define NISSY_ERROR_INVALID_MOVES    INT64_C(-20)
+#define NISSY_ERROR_INVALID_MOVES -20LL
 
 /*
 The value NISSY_ERROR_INVALID_TRANS means that the given transformation
 is invalid.
 */
-#define NISSY_ERROR_INVALID_TRANS    INT64_C(-30)
+#define NISSY_ERROR_INVALID_TRANS -30LL
 
 /*
 The value NISSY_ERROR_INVALID_FORMAT means that the given format is
 not known.
 */
-#define NISSY_ERROR_INVALID_FORMAT   INT64_C(-40)
+#define NISSY_ERROR_INVALID_FORMAT -40LL
 
 /*
 The value NISSY_ERROR_INVALID_SOLVER means that the given solver is
 not known.
 */
-#define NISSY_ERROR_INVALID_SOLVER   INT64_C(-50)
+#define NISSY_ERROR_INVALID_SOLVER -50LL
 
 /*
 The value NISSY_ERROR_NULL_POINTER means that one of the provided pointer
@@ -372,32 +354,32 @@ arguments is NULL. For example, it may be returned by solve when called
 with a solver that requires some pre-computed data, but the provided
 data is NULL.
 */
-#define NISSY_ERROR_NULL_POINTER     INT64_C(-60)
+#define NISSY_ERROR_NULL_POINTER -60LL
 
 /*
 The value NISSY_ERROR_BUFFER_SIZE means that one of the buffers provided
 is too small. For example, it could be too small to hold the result or
 too small to hold the data generated by gendata.
 */
-#define NISSY_ERROR_BUFFER_SIZE      INT64_C(-61)
+#define NISSY_ERROR_BUFFER_SIZE -61LL
 
 /*
 The value NISSY_ERROR_DATA means that the provided data is invalid. For
 example, it may be returned by solve when called with incompatible solver
 and data arguments.
 */
-#define NISSY_ERROR_DATA             INT64_C(-70)
+#define NISSY_ERROR_DATA -70LL
 
 /*
 The value NISSY_ERROR_OPTIONS means that one or more of the given options
 are invalid. For example, it may be returned by solve when called with
 a negative maximum number of solutions.
 */
-#define NISSY_ERROR_OPTIONS          INT64_C(-80)
+#define NISSY_ERROR_OPTIONS -80LL
 
 /*
 The value NISSY_ERROR_UNKNOWN denotes an unexpected error. It probably
 means that there some bug in this library.  If you can, report any error
 of this kind to sebastiano@tronto.net. Thanks!
 */
-#define NISSY_ERROR_UNKNOWN          INT64_C(-999)
+#define NISSY_ERROR_UNKNOWN -999LL
diff --git a/src/solvers/h48/solve.h b/src/solvers/h48/solve.h
index bcc8b33..36b6875 100644
--- a/src/solvers/h48/solve.h
+++ b/src/solvers/h48/solve.h
@@ -65,12 +65,13 @@ solve_h48_appendsolution(dfsarg_solveh48_t *arg)
 
         if (strl < 0)
                 goto solve_h48_appendsolution_error;
-        *arg->nextsol += strl; 
-        arg->solutions_size -= strl;
+        *arg->nextsol += strl-1; 
+        arg->solutions_size -= strl-1;
 
         if (arg->npremoves) {
                 **arg->nextsol = ' ';
                 (*arg->nextsol)++;
+                arg->solutions_size--;
 
                 invertmoves(arg->premoves, arg->npremoves, invertedpremoves);
                 strl = writemoves(invertedpremoves,
@@ -78,13 +79,14 @@ solve_h48_appendsolution(dfsarg_solveh48_t *arg)
 
                 if (strl < 0)
                         goto solve_h48_appendsolution_error;
-                *arg->nextsol += strl;
-                arg->solutions_size -= strl;
+                *arg->nextsol += strl-1;
+                arg->solutions_size -= strl-1;
         }
         LOG("Solution found: %s\n", solution);
 
         **arg->nextsol = '\n';
         (*arg->nextsol)++;
+        arg->solutions_size--;
         (*arg->nsols)++;
 
 solve_h48_appendsolution_error:
diff --git a/src/solvers/h48/solve_multithread.h b/src/solvers/h48/solve_multithread.h
index 8e00404..d8c81af 100644
--- a/src/solvers/h48/solve_multithread.h
+++ b/src/solvers/h48/solve_multithread.h
@@ -36,13 +36,14 @@ solve_h48_appendsolution_thread(dfsarg_solveh48_t *arg, task_queue_t *tq)
 
         if (strl < 0)
                 goto solve_h48_appendsolution_thread_error;
-        *arg->nextsol += strl;
-        arg->solutions_size -= strl;
+        *arg->nextsol += strl-1;
+        arg->solutions_size -= strl-1;
 
         if (arg->npremoves)
         {
                 **arg->nextsol = ' ';
                 (*arg->nextsol)++;
+                arg->solutions_size--;
 
                 invertmoves(arg->premoves, arg->npremoves, invertedpremoves);
                 strl = writemoves(invertedpremoves,
@@ -50,13 +51,14 @@ solve_h48_appendsolution_thread(dfsarg_solveh48_t *arg, task_queue_t *tq)
 
                 if (strl < 0)
                         goto solve_h48_appendsolution_thread_error;
-                *arg->nextsol += strl;
-                arg->solutions_size -= strl;
+                *arg->nextsol += strl-1;
+                arg->solutions_size -= strl-1;
         }
         LOG("Solution found: %s\n", solution);
 
         **arg->nextsol = '\n';
         (*arg->nextsol)++;
+        arg->solutions_size--;
         (*arg->nsols)++;
 
 solve_h48_appendsolution_thread_error: