Removed old scripts and updated public API

23 files changed, 317 insertions, 477 deletions

diff --git a/cpp/examples/move.cpp b/cpp/examples/move.cpp
new file mode 100644
index 0000000..970a65d
--- /dev/null
+++ b/cpp/examples/move.cpp
@@ -0,0 +1,17 @@
+/* A simple example showing how to move a cube and print it in H48 format. */
+
+#include "../nissy.h"
+#include <iostream>
+
+int main() {
+        nissy::cube c;
+        if (!c.move("R' U' F").ok()) {
+                std::cout << "Error moving the cube!" << std::endl;
+                return 1;
+        }
+
+        auto str = c.to_string();
+        std::cout << "Cube after R' U' F:" << std::endl << str << std::endl;
+
+        return 0;
+}
diff --git a/cpp/examples/move_convert.cpp b/cpp/examples/move_convert.cpp
deleted file mode 100644
index 11398df..0000000
--- a/cpp/examples/move_convert.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/* A simple example showing how to move a cube and print it in H48 format. */
-
-#include "../nissy.h"
-#include <iostream>
-
-int main() {
-        nissy::cube c;
-        if (!c.move("R' U' F").ok()) {
-                std::cout << "Error moving the cube!" << std::endl;
-                return 1;
-        }
-
-        auto string_or_error = c.to_string("H48");
-        if (std::holds_alternative<nissy::error>(string_or_error)) {
-                std::cout << "Error converting cube!" << std::endl;
-                return 1;
-        }
-
-        auto str = std::get<std::string>(string_or_error);
-        std::cout << "Cube in H48 format after R' U' F:" << std::endl
-            << str << std::endl;
-
-        return 0;
-}
diff --git a/cpp/nissy.cpp b/cpp/nissy.cpp
index 88df0f2..3535553 100644
--- a/cpp/nissy.cpp
+++ b/cpp/nissy.cpp
@@ -13,8 +13,6 @@ extern "C" {
         long long nissy_inverse(const char *, char *);
         long long nissy_applymoves(const char *, const char *, char *);
         long long nissy_applytrans(const char *, const char *, char *);
-        long long nissy_convert(const char *, const char *, const char *,
-            unsigned, char *);
         long long nissy_getcube(long long, long long, long long, long long,
             const char *, char *);
         long long nissy_solverinfo(const char *, char *);
@@ -43,7 +41,6 @@ namespace nissy {
         const error error::UNSOLVABLE_CUBE{-11};
         const error error::INVALID_MOVES{-20};
         const error error::INVALID_TRANS{-30};
-        const error error::INVALID_FORMAT{-40};
         const error error::INVALID_SOLVER{-50};
         const error error::NULL_POINTER{-60};
         const error error::BUFFER_SIZE{-61};
@@ -52,9 +49,7 @@ namespace nissy {
         const error error::UNKNOWN{-999};
 
         namespace size {
-                constexpr size_t B32 = 22;
-                constexpr size_t H48 = 88;
-                constexpr size_t CUBE_MAX = H48;
+                constexpr size_t CUBE = 22;
                 constexpr size_t TRANSFORMATION = 12;
                 constexpr size_t DATAID = 255;
         }
@@ -65,71 +60,54 @@ namespace nissy {
 
         error cube::move(const std::string& moves)
         {
-                char result[size::B32];
+                char result[size::CUBE];
                 long long err = nissy_applymoves(
-                    m_b32.c_str(), moves.c_str(), result);
+                    m_str.c_str(), moves.c_str(), result);
                 if (err < 0)
                         return error{err};
-                m_b32 = result;
+                m_str = result;
                 return error::OK;
         }
 
         error cube::transform(const std::string& trans)
         {
-                char result[size::B32];
+                char result[size::CUBE];
                 long long err = nissy_applytrans(
-                    m_b32.c_str(), trans.c_str(), result);
+                    m_str.c_str(), trans.c_str(), result);
                 if (err < 0)
                         return error{err};
-                m_b32 = result;
+                m_str = result;
                 return error::OK;
         }
 
         void cube::invert()
         {
-                char result[size::B32];
-                nissy_inverse(m_b32.c_str(), result);
-                m_b32 = result;
+                char result[size::CUBE];
+                nissy_inverse(m_str.c_str(), result);
+                m_str = result;
         }
 
         void cube::compose(const cube& other)
         {
-                char result[size::B32];
+                char result[size::CUBE];
                 nissy_compose(
-                    m_b32.c_str(), other.to_string().c_str(), result);
-                m_b32 = result;
+                    m_str.c_str(), other.to_string().c_str(), result);
+                m_str = result;
         }
 
-        std::string cube::to_string() const { return m_b32; }
-
-        std::variant<std::string, error>
-        cube::to_string(const std::string& format) const
-        {
-                char result[size::CUBE_MAX];
-                auto err = nissy_convert("B32", format.c_str(),
-                    m_b32.c_str(), size::CUBE_MAX, result);
-                if (err < 0)
-                        return error{err};
-                else
-                        return result;
-        }
+        std::string cube::to_string() const { return m_str; }
 
         std::variant<cube, error>
         cube::from_string(const std::string& str)
         {
-                return from_string(str, "B32");
-        }
-
-        std::variant<cube, error>
-        cube::from_string(const std::string& str, const std::string& format)
-        {
-                char result[size::B32];
-                cube c;
-                auto err = nissy_convert(format.c_str(),
-                    "B32", c.m_b32.c_str(), size::B32, result);
+                /* Check that the cube is valid by making a single move */
+                char result[size::CUBE];
+                auto err = nissy_applymoves(str.c_str(), "U", result);
                 if (err < 0)
                         return error{err};
-                c.m_b32 = result;
+
+                cube c;
+                c.m_str = str;
                 return c;
         }
 
@@ -143,13 +121,13 @@ namespace nissy {
         cube::get(long long ep, long long eo, long long cp, long long co,
             const std::string& options)
         {
-                char result[size::B32];
+                char result[size::CUBE];
                 cube c;
                 auto err = nissy_getcube(
                     ep, eo, cp, co, options.c_str(), result);
                 if (err < 0)
                         return error{err};
-                c.m_b32 = result;
+                c.m_str = result;
                 return c;
         }
 
diff --git a/cpp/nissy.h b/cpp/nissy.h
index 4b9c1c9..2eb0f42 100644
--- a/cpp/nissy.h
+++ b/cpp/nissy.h
@@ -38,7 +38,6 @@ namespace nissy {
                 static const error UNSOLVABLE_CUBE;
                 static const error INVALID_MOVES;
                 static const error INVALID_TRANS;
-                static const error INVALID_FORMAT;
                 static const error INVALID_SOLVER;
                 static const error NULL_POINTER;
                 static const error BUFFER_SIZE;
@@ -55,13 +54,9 @@ namespace nissy {
                 void invert();
                 void compose(const cube&);
                 std::string to_string() const;
-                std::variant<std::string, error> to_string(
-                    const std::string& format) const;
 
                 static std::variant<cube, error> from_string(
                     const std::string&);
-                static std::variant<cube, error> from_string(
-                    const std::string& str, const std::string& format);
                 static std::variant<cube, error> get(
                     long long ep, long long eo, long long cp, long long co);
                 static std::variant<cube, error> get(
@@ -69,7 +64,7 @@ namespace nissy {
                     const std::string& options);
 
         private:
-                std::string m_b32{"ABCDEFGH=ABCDEFGHIJKL"};
+                std::string m_str{"ABCDEFGH=ABCDEFGHIJKL=A"};
         };
 
         class solver {
diff --git a/python/nissy_module.c b/python/nissy_module.c
index b389297..58a5b67 100644
--- a/python/nissy_module.c
+++ b/python/nissy_module.c
@@ -4,7 +4,6 @@
 
 #include "../src/nissy.h"
 
-#define MAX_CUBE_STR_LEN 1024 /* Update when adding formats */
 #define MAX_SOLUTIONS_SIZE 250000
 
 static bool
@@ -24,7 +23,6 @@ check_error(long long err)
         case NISSY_ERROR_UNSOLVABLE_CUBE: /* Fallthrough */
         case NISSY_ERROR_INVALID_MOVES:
         case NISSY_ERROR_INVALID_TRANS:
-        case NISSY_ERROR_INVALID_FORMAT:
         case NISSY_ERROR_INVALID_SOLVER:
         case NISSY_ERROR_NULL_POINTER:
         case NISSY_ERROR_BUFFER_SIZE:
@@ -70,17 +68,17 @@ PyDoc_STRVAR(compose_doc,
 "Apply 'permutation' on 'cube'.\n"
 "\n"
 "Parameters:\n"
-"  - cube: a cube in B32 format\n"
-"  - permutation: another cube in B32 format\n"
+"  - cube: a cube\n"
+"  - permutation: another cube\n"
 "\n"
-"Returns: the resulting cube string in B32 format\n"
+"Returns: the resulting cube string\n"
 );
 static PyObject *
 compose(PyObject *self, PyObject *args)
 {
         long long err;
         const char *cube, *permutation;
-        char result[NISSY_SIZE_B32];
+        char result[NISSY_SIZE_CUBE];
 
         if (!PyArg_ParseTuple(args, "ss", &cube, &permutation))
                 return NULL;
@@ -95,16 +93,16 @@ PyDoc_STRVAR(inverse_doc,
 "Invert 'cube'.\n"
 "\n"
 "Parameters:\n"
-"  - cube: a cube in B32 format\n"
+"  - cube: a cube in\n"
 "\n"
-"Returns: the inverse cube in B32 format\n"
+"Returns: the inverse cube\n"
 );
 static PyObject *
 inverse(PyObject *self, PyObject *args)
 {
         long long err;
         const char *cube;
-        char result[NISSY_SIZE_B32];
+        char result[NISSY_SIZE_CUBE];
 
         if (!PyArg_ParseTuple(args, "s", &cube))
                 return NULL;
@@ -119,17 +117,17 @@ PyDoc_STRVAR(applymoves_doc,
 "Apply 'moves' to 'cube'.\n"
 "\n"
 "Parameters:\n"
-"  - cube: a cube in B32 format\n"
+"  - cube: a cube in\n"
 "  - moves: the moves to apply on the cube\n"
 "\n"
-"Returns: the resulting cube in B32 format\n"
+"Returns: the resulting cube\n"
 );
 static PyObject *
 applymoves(PyObject *self, PyObject *args)
 {
         long long err;
         const char *cube, *moves;
-        char result[NISSY_SIZE_B32];
+        char result[NISSY_SIZE_CUBE];
 
         if (!PyArg_ParseTuple(args, "ss", &cube, &moves))
                 return NULL;
@@ -144,19 +142,19 @@ PyDoc_STRVAR(applytrans_doc,
 "Apply 'transformation' to 'cube'.\n"
 "\n"
 "Parameters:\n"
-"  - cube: a cube in B32 format\n"
+"  - cube: a cube\n"
 "  - transformation: the transformation to apply on the cube, formatted as\n"
 "    (rotation|mirrored) (2 letters)\n"
 "    for example 'mirrored ur' or 'rotation lf'\n"
 "\n"
-"Returns: the resulting cube in B32 format\n"
+"Returns: the resulting cube\n"
 );
 static PyObject *
 applytrans(PyObject *self, PyObject *args)
 {
         long long err;
         const char *cube, *trans;
-        char result[NISSY_SIZE_B32];
+        char result[NISSY_SIZE_CUBE];
 
         if (!PyArg_ParseTuple(args, "ss", &cube, &trans))
                 return NULL;
@@ -165,32 +163,6 @@ applytrans(PyObject *self, PyObject *args)
         return string_result(err, result);
 }
 
-PyDoc_STRVAR(convert_doc,
-"convert(fin, fout, cube)\n"
-"--\n\n"
-"Convert 'cube' from format 'fin' to format 'fout'.\n"
-"\n"
-"Parameters:\n"
-"  - fin: the format in which 'cube' is given\n"
-"  - fout: the format to which 'cube' has to be converted\n"
-"  - cube: a cube in B32 format\n"
-"\n"
-"Returns: 'cube' in 'fout' format\n"
-);
-static PyObject *
-convert(PyObject *self, PyObject *args)
-{
-        long long err;
-        const char *fin, *fout, *cube;
-        char result[MAX_CUBE_STR_LEN];
-
-        if (!PyArg_ParseTuple(args, "sss", &fin, &fout, &cube))
-                return NULL;
-
-        err = nissy_convert(fin, fout, cube, MAX_CUBE_STR_LEN, result);
-        return string_result(err, result);
-}
-
 PyDoc_STRVAR(getcube_doc,
 "getcube(ep, eo, cp, co, options)\n"
 "--\n\n"
@@ -210,7 +182,7 @@ getcube(PyObject *self, PyObject *args)
 {
         long long ep, eo, cp, co, err;
         const char *options;
-        char result[NISSY_SIZE_B32];
+        char result[NISSY_SIZE_CUBE];
 
         if (!PyArg_ParseTuple(args, "LLLLs", &ep, &eo, &cp, &co, &options))
                 return NULL;
@@ -321,7 +293,7 @@ PyDoc_STRVAR(solve_doc,
 "See the documentation for libnissy (in nissy.h) for details.\n"
 "\n"
 "Parameters:\n"
-"  - cube: a cube in B32 format\n"
+"  - cube: a cube\n"
 "  - solver: the solver to use\n"
 "  - minmoves: the minimum number of moves to use\n"
 "  - maxmoves: the maximum number of moves to use\n"
@@ -400,7 +372,6 @@ static PyMethodDef nissy_methods[] = {
         { "inverse", inverse, METH_VARARGS, inverse_doc },
         { "applymoves", applymoves, METH_VARARGS, applymoves_doc },
         { "applytrans", applytrans, METH_VARARGS, applytrans_doc },
-        { "convert", convert, METH_VARARGS, convert_doc },
         { "getcube", getcube, METH_VARARGS, getcube_doc },
         { "solverinfo", solverinfo, METH_VARARGS, solverinfo_doc },
         { "gendata", gendata, METH_VARARGS, gendata_doc },
diff --git a/shell/shell.c b/shell/shell.c
index 104e7e0..ecd39f2 100644
--- a/shell/shell.c
+++ b/shell/shell.c
@@ -18,9 +18,6 @@
 #define FLAG_PERM         "-perm"
 #define FLAG_COMMAND      "-command"
 #define FLAG_STR_CUBE     "-cubestr"
-#define FLAG_FORMAT       "-format"
-#define FLAG_FORMAT_IN    "-fin"
-#define FLAG_FORMAT_OUT   "-fout"
 #define FLAG_MOVES        "-moves"
 #define FLAG_TRANS        "-trans"
 #define FLAG_SOLVER       "-solver"
@@ -31,23 +28,18 @@
 #define FLAG_MAXSOLUTIONS "-n"
 #define FLAG_THREADS      "-t"
 
-#define INFO_CUBEFORMAT(cube) cube " must be given in B32 format."
 #define INFO_MOVESFORMAT "The accepted moves are U, D, R, L, F and B, " \
     "optionally followed by a 2, a ' or a 3."
 #define INFO_TRANSFORMAT "The transformation must be given in the format " \
     "(rotation|mirrored) (2 letters), for exmple " \
     "'rotation UF' or 'mirrored BL'."
-#define INFO_FORMATS "The available formats are H48, B32 and SRC."
 
 typedef struct {
         int command_index;
-        char cube[22];
-        char cube_perm[22];
+        char cube[NISSY_SIZE_CUBE];
+        char cube_perm[NISSY_SIZE_CUBE];
         char *str_command;
         char *str_cube;
-        char *str_format;
-        char *str_format_in;
-        char *str_format_out;
         char *str_moves;
         char *str_trans;
         char *str_solver;
@@ -64,7 +56,6 @@ static int64_t inverse_exec(args_t *);
 static int64_t applymoves_exec(args_t *);
 static int64_t applytrans_exec(args_t *);
 static int64_t frommoves_exec(args_t *);
-static int64_t convert_exec(args_t *);
 static int64_t randomcube_exec(args_t *);
 static int64_t solverinfo_exec(args_t *);
 static int64_t gendata_exec(args_t *);
@@ -81,9 +72,6 @@ static bool set_cube(int, char **, args_t *);
 static bool set_cube_perm(int, char **, args_t *);
 static bool set_str_command(int, char **, args_t *);
 static bool set_str_cube(int, char **, args_t *);
-static bool set_str_format(int, char **, args_t *);
-static bool set_str_format_in(int, char **, args_t *);
-static bool set_str_format_out(int, char **, args_t *);
 static bool set_str_moves(int, char **, args_t *);
 static bool set_str_trans(int, char **, args_t *);
 static bool set_str_solver(int, char **, args_t *);
@@ -107,9 +95,6 @@ struct {
         OPTION(FLAG_PERM, 1, set_cube_perm),
         OPTION(FLAG_COMMAND, 1, set_str_command),
         OPTION(FLAG_STR_CUBE, 1, set_str_cube),
-        OPTION(FLAG_FORMAT, 1, set_str_format),
-        OPTION(FLAG_FORMAT_IN, 1, set_str_format_in),
-        OPTION(FLAG_FORMAT_OUT, 1, set_str_format_out),
         OPTION(FLAG_MOVES, 1, set_str_moves),
         OPTION(FLAG_TRANS, 1, set_str_trans),
         OPTION(FLAG_SOLVER, 1, set_str_solver),
@@ -133,29 +118,27 @@ struct {
         COMMAND(
                 "compose",
                 "compose " FLAG_CUBE " CUBE " FLAG_PERM " PERM",
-                "Apply on CUBE the permutation defined by PERM. "
-                INFO_CUBEFORMAT("CUBE and PERM"),
+                "Apply on CUBE the permutation defined by PERM.",
                 compose_exec
         ),
         COMMAND(
                 "inverse",
                 "inverse " FLAG_CUBE " CUBE ",
-                "Compute the inverse of the given CUBE. "
-                INFO_CUBEFORMAT("CUBE"),
+                "Compute the inverse of the given CUBE.",
                 inverse_exec
         ),
         COMMAND(
                 "applymoves",
                 "applymoves " FLAG_CUBE " CUBE " FLAG_MOVES " MOVES",
                 "Apply the given MOVES to the given CUBE. "
-                INFO_CUBEFORMAT("CUBE") " " INFO_MOVESFORMAT,
+                INFO_MOVESFORMAT,
                 applymoves_exec
         ),
         COMMAND(
                 "applytrans",
                 "applytrans " FLAG_CUBE " CUBE " FLAG_TRANS " TRANS",
                 "Apply the single transformation TRANS to the given CUBE. "
-                INFO_CUBEFORMAT("CUBE") " " INFO_TRANSFORMAT,
+                INFO_TRANSFORMAT,
                 applytrans_exec
         ),
         COMMAND(
@@ -166,19 +149,9 @@ struct {
                 frommoves_exec
         ),
         COMMAND(
-                "convert",
-                "convert " FLAG_STR_CUBE " CUBESTR "
-                FLAG_FORMAT_IN " FORMAT_IN " FLAG_FORMAT_OUT " FORMAT_OUT",
-                "Convert the cube described by CUBESTR from FORMAT_IN to "
-                "FORMAT_OUT."
-                INFO_FORMATS " "
-                "CUBESTR must be a valid cube in the FORMAT_IN format.",
-                convert_exec
-        ),
-        COMMAND(
                 "randomcube",
                 "randomcube",
-                "Returns a random cube in B32 format.",
+                "Returns a random.",
                 randomcube_exec
         ),
         COMMAND(
@@ -202,8 +175,7 @@ struct {
                 FLAG_CUBE " CUBE"
                 FLAG_THREADS " T",
                 "Solve the given CUBE using SOLVER, "
-                "using at least n and at most N moves, and T threads. "
-                INFO_CUBEFORMAT("CUBE"),
+                "using at least n and at most N moves, and T threads.",
                 solve_exec
         ),
         COMMAND(
@@ -254,7 +226,7 @@ rand64(void)
 static int64_t
 compose_exec(args_t *args)
 {
-        char result[22];
+        char result[NISSY_SIZE_CUBE];
         int64_t ret;
 
         ret = nissy_compose(args->cube, args->cube_perm, result);
@@ -267,7 +239,7 @@ compose_exec(args_t *args)
 static int64_t
 inverse_exec(args_t *args)
 {
-        char result[22];
+        char result[NISSY_SIZE_CUBE];
         int64_t ret;
 
         ret = nissy_inverse(args->cube, result);
@@ -280,7 +252,7 @@ inverse_exec(args_t *args)
 static int64_t
 applymoves_exec(args_t *args)
 {
-        char result[22];
+        char result[NISSY_SIZE_CUBE];
         int64_t ret;
 
         ret = nissy_applymoves(args->cube, args->str_moves, result);
@@ -293,7 +265,7 @@ applymoves_exec(args_t *args)
 static int64_t
 applytrans_exec(args_t *args)
 {
-        char result[22];
+        char result[NISSY_SIZE_CUBE];
         int64_t ret;
 
         ret = nissy_applytrans(args->cube, args->str_trans, result);
@@ -311,20 +283,6 @@ frommoves_exec(args_t *args)
 }
 
 static int64_t
-convert_exec(args_t *args)
-{
-        char result[PRINTCUBE_BUFFER_SIZE];
-        int64_t ret;
-
-        ret = nissy_convert(args->str_format_in, args->str_format_out,
-            args->str_cube, PRINTCUBE_BUFFER_SIZE, result);
-        if (ret == NISSY_OK || ret == NISSY_WARNING_UNSOLVABLE)
-                printf("%s\n", result);
-
-        return ret;
-}
-
-static int64_t
 randomcube_exec(args_t *args)
 {
         char result[PRINTCUBE_BUFFER_SIZE];
@@ -575,9 +533,6 @@ parse_args(int argc, char **argv, args_t *args)
                 .cube = "",
                 .cube_perm = "",
                 .str_cube = "",
-                .str_format = "",
-                .str_format_in = "",
-                .str_format_out = "",
                 .str_moves = "",
                 .str_trans = "",
                 .str_solver = "",
@@ -668,7 +623,7 @@ parse_nisstype(const char *arg)
 static bool
 set_cube(int argc, char **argv, args_t *args)
 {
-        memcpy(args->cube, argv[0], 22);
+        memcpy(args->cube, argv[0], NISSY_SIZE_CUBE);
         args->cube[21] = 0;
 
         return true;
@@ -677,7 +632,7 @@ set_cube(int argc, char **argv, args_t *args)
 static bool
 set_cube_perm(int argc, char **argv, args_t *args)
 {
-        memcpy(args->cube_perm, argv[0], 22);
+        memcpy(args->cube_perm, argv[0], NISSY_SIZE_CUBE);
         args->cube_perm[21] = 0;
 
         return true;
@@ -700,30 +655,6 @@ set_str_cube(int argc, char **argv, args_t *args)
 }
 
 static bool
-set_str_format(int argc, char **argv, args_t *args)
-{
-        args->str_format = argv[0];
-
-        return true;
-}
-
-static bool
-set_str_format_in(int argc, char **argv, args_t *args)
-{
-        args->str_format_in = argv[0];
-
-        return true;
-}
-
-static bool
-set_str_format_out(int argc, char **argv, args_t *args)
-{
-        args->str_format_out = argv[0];
-
-        return true;
-}
-
-static bool
 set_str_moves(int argc, char **argv, args_t *args)
 {
         args->str_moves = argv[0];
diff --git a/src/core/core.h b/src/core/core.h
index de1c198..fce1751 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -1,5 +1,4 @@
 #include "constant_cubes.h"
 #include "cube.h"
-#include "io_formats.h"
 #include "moves.h"
 #include "transform.h"
diff --git a/src/core/cube.h b/src/core/cube.h
index ce8a6b8..798c99c 100644
--- a/src/core/cube.h
+++ b/src/core/cube.h
@@ -174,3 +174,193 @@ getcube(int64_t ep, int64_t eo, int64_t cp, int64_t co)
 
         return cubefromarray(carr, earr);
 }
+
+
+/******************************************************************************/
+
+STATIC cube_t readcube(const char *, const char *);
+STATIC int64_t writecube(const char *, cube_t, size_t n, char [n]);
+STATIC uint8_t readco(const char *);
+STATIC uint8_t readcp(const char *);
+STATIC uint8_t readeo(const char *);
+STATIC uint8_t readep(const char *);
+
+STATIC cube_t readcube_B32(const char *);
+STATIC int64_t writecube_B32(cube_t, size_t n, char [n]);
+
+STATIC uint8_t b32toedge(char);
+STATIC uint8_t b32tocorner(char);
+STATIC char edgetob32(uint8_t);
+STATIC char cornertob32(uint8_t);
+
+STATIC cube_t
+readcube(const char *format, const char *buf)
+{
+        return readcube_B32(buf);
+}
+
+STATIC int64_t
+writecube(const char *format, cube_t cube, size_t buf_size, char buf[buf_size])
+{
+        return writecube_B32(cube, buf_size, buf);
+}
+
+STATIC uint8_t
+readco(const char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return CTWIST_CW;
+        if (*str == '2')
+                return CTWIST_CCW;
+
+        LOG("Error reading CO\n");
+        return UINT8_ERROR;
+}
+
+STATIC uint8_t
+readcp(const char *str)
+{
+        uint8_t c;
+
+        for (c = 0; c < 8; c++)
+                if (!strncmp(str, cornerstr[c], 3) ||
+                    !strncmp(str, cornerstralt[c], 3))
+                        return c;
+
+        LOG("Error reading CP\n");
+        return UINT8_ERROR;
+}
+
+STATIC uint8_t
+readeo(const char *str)
+{
+        if (*str == '0')
+                return 0;
+        if (*str == '1')
+                return EFLIP;
+
+        LOG("Error reading EO\n");
+        return UINT8_ERROR;
+}
+
+STATIC uint8_t
+readep(const char *str)
+{
+        uint8_t e;
+
+        for (e = 0; e < 12; e++)
+                if (!strncmp(str, edgestr[e], 2))
+                        return e;
+
+        LOG("Error reading EP\n");
+        return UINT8_ERROR;
+}
+
+STATIC cube_t
+readcube_B32(const char *buf)
+{
+        int i;
+        uint8_t c[8], e[12];
+
+        for (i = 0; i < 8; i++) {
+                c[i] = b32tocorner(buf[i]);
+                if (c[i] == UINT8_ERROR) {
+                        LOG("Error reading B32 corner %d ", i);
+                        if (buf[i] == 0) {
+                                LOG("(string terminated early)\n");
+                        } else {
+                                LOG("(char '%c')\n", buf[i]);
+                        }
+                        return ZERO_CUBE;
+                }
+        }
+
+        if (buf[8] != '=') {
+                LOG("Error reading B32 separator: a single '=' "
+                    "must be used to separate edges and corners\n");
+                return ZERO_CUBE;
+        }
+
+        for (i = 0; i < 12; i++) {
+                e[i] = b32toedge(buf[i+9]);
+                if (e[i] == UINT8_ERROR) {
+                        LOG("Error reading B32 edge %d ", i);
+                        if (buf[i+9] == 0) {
+                                LOG("(string terminated early)\n");
+                        } else {
+                                LOG("(char '%c')\n", buf[i+9]);
+                        }
+                        return ZERO_CUBE;
+                }
+        }
+
+        return cubefromarray(c, e);
+}
+
+STATIC int64_t
+writecube_B32(cube_t cube, size_t buf_size, char buf[buf_size])
+{
+        int i;
+        uint8_t corner[8], edge[12];
+
+        if (buf_size < NISSY_SIZE_CUBE) {
+                LOG("Cannot write cube: buffer size must be at least %u "
+                    "bytes, but the provided one is %zu bytes.\n",
+                    NISSY_SIZE_CUBE, buf_size);
+                return NISSY_ERROR_BUFFER_SIZE;
+        }
+
+        pieces(&cube, corner, edge);
+
+        for (i = 0; i < 8; i++)
+                buf[i] = cornertob32(corner[i]);
+
+        buf[8] = '=';
+
+        for (i = 0; i < 12; i++)
+                buf[i+9] = edgetob32(edge[i]);
+
+        buf[21] = '\0';
+
+        return NISSY_OK;
+}
+
+STATIC uint8_t
+b32toedge(char c)
+{
+        if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'f')))
+                return UINT8_ERROR;
+
+        return c <= 'Z' ? (uint8_t)(c - 'A') : (uint8_t)(c - 'a') + 26;
+}
+
+STATIC uint8_t
+b32tocorner(char c) {
+        uint8_t val;
+
+        if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'f')))
+                return UINT8_ERROR;
+
+        val = c <= 'Z' ? (uint8_t)(c - 'A') : (uint8_t)(c - 'a') + 26;
+
+        return (val & 7) | ((val & 24) << 2);
+}
+
+STATIC char
+edgetob32(uint8_t edge)
+{
+        return edge < 26 ? 'A' + (char)edge : 'a' + (char)(edge - 26);
+}
+
+STATIC char
+cornertob32(uint8_t corner)
+{
+        uint8_t val;
+
+        val = (corner & 7) | ((corner & 96) >> 2);
+
+        return val < 26 ? 'A' + (char)val : 'a' + (char)(val - 26);
+}
+/******************************************************************************/
diff --git a/src/nissy.c b/src/nissy.c
index dfa1a90..fb3cc11 100644
--- a/src/nissy.c
+++ b/src/nissy.c
@@ -17,7 +17,7 @@ long long parse_h48_solver(
 STATIC bool checkdata(const unsigned char *, const tableinfo_t [static 1]);
 STATIC bool distribution_equal(const uint64_t [static INFO_DISTRIBUTION_LEN],
     const uint64_t [static INFO_DISTRIBUTION_LEN], uint8_t);
-STATIC long long write_result(cube_t, char [static NISSY_SIZE_B32]);
+STATIC long long write_result(cube_t, char [static NISSY_SIZE_CUBE]);
 STATIC size_t my_strnlen(const char *, size_t); 
 STATIC long long nissy_dataid(const char *, char [static NISSY_SIZE_DATAID]);
 STATIC long long nissy_gendata_unsafe(
@@ -117,9 +117,9 @@ distribution_equal(
 }
 
 STATIC long long
-write_result(cube_t cube, char result[static NISSY_SIZE_B32])
+write_result(cube_t cube, char result[static NISSY_SIZE_CUBE])
 {
-        writecube("B32", cube, NISSY_SIZE_B32, result);
+        writecube("B32", cube, NISSY_SIZE_CUBE, result);
 
         if (!issolvable(cube)) {
                 LOG("Warning: resulting cube is not solvable\n");
@@ -143,9 +143,9 @@ my_strnlen(const char *str, size_t maxlen)
 
 long long
 nissy_compose(
-        const char cube[static NISSY_SIZE_B32],
-        const char permutation[static NISSY_SIZE_B32],
-        char result[static NISSY_SIZE_B32]
+        const char cube[static NISSY_SIZE_CUBE],
+        const char permutation[static NISSY_SIZE_CUBE],
+        char result[static NISSY_SIZE_CUBE]
 )
 {
         cube_t c, p, res;
@@ -178,14 +178,14 @@ nissy_compose(
         return write_result(res, result);
 
 nissy_compose_error:
-        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
 long long
 nissy_inverse(
-        const char cube[static NISSY_SIZE_B32],
-        char result[static NISSY_SIZE_B32]
+        const char cube[static NISSY_SIZE_CUBE],
+        char result[static NISSY_SIZE_CUBE]
 )
 {
         cube_t c, res;
@@ -210,15 +210,15 @@ nissy_inverse(
         return write_result(res, result);
 
 nissy_inverse_error:
-        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
 long long
 nissy_applymoves(
-        const char cube[static NISSY_SIZE_B32],
+        const char cube[static NISSY_SIZE_CUBE],
         const char *moves,
-        char result[static NISSY_SIZE_B32]
+        char result[static NISSY_SIZE_CUBE]
 )
 {
         cube_t c, res;
@@ -249,15 +249,15 @@ nissy_applymoves(
         return write_result(res, result);
 
 nissy_applymoves_error:
-        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
 long long
 nissy_applytrans(
-        const char cube[static NISSY_SIZE_B32],
+        const char cube[static NISSY_SIZE_CUBE],
         const char transformation[static NISSY_SIZE_TRANSFORMATION],
-        char result[static NISSY_SIZE_B32]
+        char result[static NISSY_SIZE_CUBE]
 )
 {
         cube_t c, res;
@@ -282,51 +282,7 @@ nissy_applytrans(
         return write_result(res, result);
 
 nissy_applytrans_error:
-        writecube("B32", ZERO_CUBE, NISSY_SIZE_B32, result);
-        return err;
-}
-
-long long
-nissy_convert(
-        const char *format_in,
-        const char *format_out,
-        const char *cube_string,
-        unsigned result_size,
-        char result[result_size]
-)
-{
-        cube_t c;
-        long long err;
-
-        if (format_in == NULL) {
-                LOG("[convert] Error: 'format_in' argument is NULL\n");
-                err = NISSY_ERROR_NULL_POINTER;
-                goto nissy_convert_error;
-        }
-
-        if (format_out == NULL) {
-                LOG("[convert] Error: 'format_out' argument is NULL\n");
-                err = NISSY_ERROR_NULL_POINTER;
-                goto nissy_convert_error;
-        }
-
-        if (cube_string == NULL) {
-                LOG("[convert] Error: 'cube_string' argument is NULL\n");
-                err = NISSY_ERROR_NULL_POINTER;
-                goto nissy_convert_error;
-        }
-
-        c = readcube(format_in, cube_string);
-
-        if (!isconsistent(c)) {
-                err = NISSY_ERROR_INVALID_CUBE;
-                goto nissy_convert_error;
-        }
-
-        return writecube(format_out, c, result_size, result);
-
-nissy_convert_error:
-        result[0] = '\0';
+        writecube("B32", ZERO_CUBE, NISSY_SIZE_CUBE, result);
         return err;
 }
 
@@ -337,7 +293,7 @@ nissy_getcube(
         long long cp,
         long long co,
         const char *options,
-        char result[static NISSY_SIZE_B32]
+        char result[static NISSY_SIZE_CUBE]
 )
 {
         int i;
@@ -526,7 +482,7 @@ nissy_checkdata(
 
 long long
 nissy_solve(
-        const char cube[static NISSY_SIZE_B32],
+        const char cube[static NISSY_SIZE_CUBE],
         const char *solver, 
         unsigned nissflag,
         unsigned minmoves,
diff --git a/src/nissy.h b/src/nissy.h
index a5b3015..963571f 100644
--- a/src/nissy.h
+++ b/src/nissy.h
@@ -5,12 +5,11 @@ 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.
 
-All cube arguments are in B32 formats, unless otherwise specified.
-Other available formats are H48 and SRC. See README.md for more info on
-these formats.
+TODO: explain cube format
 
 Accepted moves are U, D, R, L, F and B, optionally followed by a 2,
 a ' or a 3.
+TODO update when we accept also wide moves, slices and rotations
 
 A transformation must be given in the format
     (rotation|mirrored) (2 letters)
@@ -21,9 +20,7 @@ for example 'rotation UF' or 'mirrored BL'.
 /* Constants *****************************************************************/
 
 /* Some constants for size for I/O buffers */
-#define NISSY_SIZE_B32            22U
-#define NISSY_SIZE_H48            88U
-#define NISSY_SIZE_CUBE_MAX       NISSY_SIZE_H48
+#define NISSY_SIZE_CUBE           24U
 #define NISSY_SIZE_TRANSFORMATION 12U
 #define NISSY_SIZE_SOLVE_STATS    10U
 #define NISSY_SIZE_DATAID         255U
@@ -37,8 +34,8 @@ for example 'rotation UF' or 'mirrored BL'.
 #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"
+/* The solved cube */
+#define NISSY_SOLVED_CUBE "ABCDEFGH=ABCDEFGHIJKL=A"
 
 /* Error codes ***************************************************************/
 
@@ -58,8 +55,7 @@ provided an unsolvable cube as input.
 
 /*
 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.
+invalid. It could be written in an unknown format, or be ill-formed.
 */
 #define NISSY_ERROR_INVALID_CUBE -10LL
 
@@ -85,12 +81,6 @@ is invalid.
 #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 -40LL
-
-/*
 The value NISSY_ERROR_INVALID_SOLVER means that the given solver is
 not known.
 */
@@ -139,10 +129,10 @@ of this kind to sebastiano@tronto.net. Thanks!
 Apply the secod argument as a permutation on the first argument.
 
 Parameters:
-   cube        - The first cube, in B32 format.
-   permutation - The second cube, in B32 format. This cube is treated as a
-                 permutation and "applied" to the first cube.
-   result      - The return parameter for the resulting cube, in B32 format.
+   cube        - The first cube.
+   permutation - The second cub. This cube is treated as a permutation and
+                 "applied" to the first cube.
+   result      - The return parameter for the resulting cube.
 
 Return values:
    NISSY_OK                  - The cubes were composed succesfully.
@@ -155,17 +145,17 @@ Return values:
 */
 long long
 nissy_compose(
-        const char cube[static NISSY_SIZE_B32],
-        const char permutation[static NISSY_SIZE_B32],
-        char result[static NISSY_SIZE_B32]
+        const char cube[static NISSY_SIZE_CUBE],
+        const char permutation[static NISSY_SIZE_CUBE],
+        char result[static NISSY_SIZE_CUBE]
 );
 
 /*
 Compute the inverse of the given cube.
 
 Parameters:
-   cube   - The cube to be inverted, in B32 format.
-   result - The return parameter for the resulting cube, in B32 format.
+   cube   - The cube to be inverted.
+   result - The return parameter for the resulting cube.
 
 Return values:
    NISSY_OK                  - The cube was inverted succesfully.
@@ -177,17 +167,17 @@ Return values:
 */
 long long
 nissy_inverse(
-        const char cube[static NISSY_SIZE_B32],
-        char result[static NISSY_SIZE_B32]
+        const char cube[static NISSY_SIZE_CUBE],
+        char result[static NISSY_SIZE_CUBE]
 );
 
 /*
 Apply the given sequence of moves on the given cube.
 
 Parameters:
-   cube   - The cube to move, in B32 format.
+   cube   - The cube to move.
    moves  - The moves to apply to the cube. Must be a NULL-terminated string.
-   result - The return parameter for the resulting cube, in B32 format.
+   result - The return parameter for the resulting cube.
 
 Return values:
    NISSY_OK                  - The moves were applied succesfully.
@@ -200,18 +190,18 @@ Return values:
 */
 long long
 nissy_applymoves(
-        const char cube[static NISSY_SIZE_B32],
+        const char cube[static NISSY_SIZE_CUBE],
         const char *moves,
-        char result[static NISSY_SIZE_B32]
+        char result[static NISSY_SIZE_CUBE]
 );
 
 /*
 Apply the single given transformation to the given cube.
 
 Parameters:
-   cube           - The cube to be transformed, in B32 format.
-   transformation - The transformation in (rotation|mirrored) xy format.
-   result         - The return parameter for the resulting cube, in B32 format.
+   cube           - The cube to be transformed.
+   transformation - The transformation in "(rotation|mirrored) __" format.
+   result         - The return parameter for the resulting cube.
 
 Return values:
    NISSY_OK                  - The transformation was performed succesfully.
@@ -222,37 +212,9 @@ Return values:
 */
 long long
 nissy_applytrans(
-        const char cube[static NISSY_SIZE_B32],
+        const char cube[static NISSY_SIZE_CUBE],
         const char transformation[static NISSY_SIZE_TRANSFORMATION],
-        char result[static NISSY_SIZE_B32]
-);
-
-/*
-Convert the given cube between the two given formats.
-
-Parameters:
-   format_in   - The input format.
-   format_out  - The output format.
-   cube_string - The cube, in format_in format.
-   result_size - The allocated size of the result array.
-   result      - Return parameter for the cube in format_out format.
-
-Return values:
-   NISSY_OK                   - The conversion was performed succesfully.
-   NISSY_ERROR_BUFFER_SIZE    - The given buffer is too small for the result.
-   NISSY_ERROR_INVALID_CUBE   - The given cube is invalid.
-   NISSY_ERROR_INVALID_FORMAT - At least one of the given formats is invalid.
-   NISSY_ERROR_UNKNOWN        - An unknown error occurred.
-   NISSY_ERROR_NULL_POINTER   - At least one of 'format_in', 'format_out' or
-                                'cube_string' arguments is NULL.
-*/
-long long
-nissy_convert(
-        const char *format_in,
-        const char *format_out,
-        const char *cube_string,
-        unsigned result_size,
-        char result[result_size]
+        char result[static NISSY_SIZE_CUBE]
 );
 
 /*
@@ -267,7 +229,7 @@ Parameters:
    cp      - The corner permutation, 0 <= cp <= 40320 (8!)
    co      - The corner orientation, 0 <= co <= 2187 (3^7)
    options - Other options.
-   result  - The return parameter for the resulting cube, in B32 format.
+   result  - The return parameter for the resulting cube.
 
 Return values:
    NISSY_OK                 - The cube was generated succesfully.
@@ -281,7 +243,7 @@ nissy_getcube(
         long long cp,
         long long co,
         const char *options,
-        char result[static NISSY_SIZE_B32]
+        char result[static NISSY_SIZE_CUBE]
 );
 
 /*
@@ -354,7 +316,7 @@ nissy_checkdata(
 Solve the given cube using the given solver and options.
 
 Parameters:
-   cube      - The cube to solver, in B32 format.
+   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.
@@ -386,7 +348,7 @@ Return values:
 */
 long long
 nissy_solve(
-        const char cube[static NISSY_SIZE_B32],
+        const char cube[static NISSY_SIZE_CUBE],
         const char *solver, 
         unsigned nissflag,
         unsigned minmoves,
diff --git a/tools/300_solve_small/solve_small.c b/tools/300_solve_small/solve_small.c
index 2efbcb5..dcd47c1 100644
--- a/tools/300_solve_small/solve_small.c
+++ b/tools/300_solve_small/solve_small.c
@@ -25,7 +25,7 @@ void run(void) {
         int i;
         int64_t n;
         long long stats[NISSY_SIZE_SOLVE_STATS];
-        char sol[SOL_BUFFER_LEN], cube[22];
+        char sol[SOL_BUFFER_LEN], cube[NISSY_SIZE_CUBE];
 
         printf("Solved the following scrambles:\n\n");
         for (i = 0; scrambles[i] != NULL; i++) {
diff --git a/tools/301_solve_file/solve_file.c b/tools/301_solve_file/solve_file.c
index fcc018d..d9084fd 100644
--- a/tools/301_solve_file/solve_file.c
+++ b/tools/301_solve_file/solve_file.c
@@ -12,7 +12,7 @@ char scrambles[MAX_SCR][MAX_SCR_LEN];
 void run(void) {
         int64_t i, nsols;
         long long stats[NISSY_SIZE_SOLVE_STATS];
-        char sol[SOL_BUFFER_LEN], cube[22];
+        char sol[SOL_BUFFER_LEN], cube[NISSY_SIZE_CUBE];
 
         printf("Solved the following scrambles:\n\n");
         for (i = 0; i < N; i++) {
diff --git a/tools/302_solve_multisol/solve_multisol.c b/tools/302_solve_multisol/solve_multisol.c
index f6057d7..a2896a9 100644
--- a/tools/302_solve_multisol/solve_multisol.c
+++ b/tools/302_solve_multisol/solve_multisol.c
@@ -18,7 +18,7 @@ void run(void) {
         int i;
         int64_t n;
         long long stats[NISSY_SIZE_SOLVE_STATS];
-        char sol[SOL_BUFFER_LEN], cube[22];
+        char sol[SOL_BUFFER_LEN], cube[NISSY_SIZE_CUBE];
 
         printf("Solved the following scrambles:\n\n");
         for (i = 0; scrambles[i] != NULL; i++) {
diff --git a/tools/400_solvetest/solve_test.c b/tools/400_solvetest/solve_test.c
index a724320..1bfe851 100644
--- a/tools/400_solvetest/solve_test.c
+++ b/tools/400_solvetest/solve_test.c
@@ -45,7 +45,7 @@ void run(void) {
         int i;
         int64_t n;
         long long stats[NISSY_SIZE_SOLVE_STATS];
-        char sol[SOL_BUFFER_LEN], cube[22];
+        char sol[SOL_BUFFER_LEN], cube[NISSY_SIZE_CUBE];
 
         for (i = 0; s[i].scramble[0]; i++) {
                 printf("\n%d. %s\n", i, s[i].scramble);
diff --git a/src/core/io_formats.h b/utils/convert.c
index f5668d4..4f4bb8c 100644
--- a/src/core/io_formats.h
+++ b/utils/convert.c
@@ -1,3 +1,9 @@
+/*
+This file contains code related to cube format conversion that used to
+be in src/core.  It is to be adapted into a standalone tool for cube
+format conversion.
+*/
+
 STATIC cube_t readcube(const char *, const char *);
 STATIC int64_t writecube(const char *, cube_t, size_t n, char [n]);
 STATIC void log_available_formats(void);
diff --git a/utils/genmovecode.sh b/utils/genmovecode.sh
deleted file mode 100755
index cf13441..0000000
--- a/utils/genmovecode.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-#!/bin/sh
-
-cc -DDEBUG h48_to_lst.c ../src/nissy.c -o h48_to_lst
-
-gen() {
-        for f in cubes/move_??_*.txt; do
-                move="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-                printf '#define _move_cube_%s fastcube( \\\n    ' "$move"
-                ./h48_to_lst <"$f"
-                printf ')\n'
-        done
-}
-
-gen
-rm -f h48_to_lst invert
diff --git a/utils/genmoveswitch.sh b/utils/genmoveswitch.sh
deleted file mode 100755
index 3b2a74b..0000000
--- a/utils/genmoveswitch.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-
-printf '\tswitch (m) {\n'
-for f in cubes/move_??_*.txt; do
-        t="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-        printf '\tcase %s:\n\t\treturn _move(%s, c);\n' "$t" "$t"
-done
-printf '\t}\n'
diff --git a/utils/gentranscode.sh b/utils/gentranscode.sh
deleted file mode 100755
index 9a1de2c..0000000
--- a/utils/gentranscode.sh
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/bin/sh
-
-cc -DDEBUG h48_to_lst.c ../src/nissy.c -o h48_to_lst
-cc -DDEBUG invert.c ../src/nissy.c -o invert
-
-lineavx() { printf '#define _trans_cube_%s ' "$1"; }
-linesrc() { printf '_static cube_fast_t _trans_cube_%s = ' "$1"; }
-sedavx() { sed '1,2s/$/ \\/ ; 3s/$/)/ ; 3q'; }
-sedsrc() { sed '3s/$/ };/ ; 3q'; }
-
-gen() {
-        for f in cubes/transform_??_???.txt; do
-                trans="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-                printf '#define _trans_cube_%s fastcube( \\\n    ' "$trans"
-                ./h48_to_lst <"$f"
-                printf ')\n'
-                printf '#define _trans_cube_%s_inverse fastcube( \\\n    ' \
-                        "$trans"
-                ./invert <"$f" | ./h48_to_lst
-                printf ')\n'
-        done
-}
-
-gen
-rm -f h48_to_lst invert
diff --git a/utils/gentransswitch.sh b/utils/gentransswitch.sh
deleted file mode 100755
index 20e2bfb..0000000
--- a/utils/gentransswitch.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-printf '\tswitch (t) {\n'
-for f in cubes/transform_??_???.txt; do
-        t="$(echo "$f" | sed 's/.*_// ; s/\.txt//')"
-        mirror_or_rotation="$(echo "$t" | grep m)"
-        if [ -z "$mirror_or_rotation" ]; then
-                m="rotation"
-        else
-                m="mirrored"
-        fi
-        printf '\tcase %s:\n\t\treturn _trans_%s(%s, c);\n' "$t" "$m" "$t"
-done
-printf '\t}\n'
diff --git a/utils/gentranstests.sh b/utils/gentranstests.sh
deleted file mode 100755
index a257a0a..0000000
--- a/utils/gentranstests.sh
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/bin/sh
-
-outdir="./generated_trans_tests"
-
-mkdir -p "$outdir"
-i=100
-
-while read -r line; do
-        [ -z "$line" ] && continue
-
-        trans_piece="$(echo "$line" | awk '{print $1}' | tr -d 'rm')"
-        move1="$(echo "$line" | awk '{print $2}')"
-        move2="$(echo "$line" | awk '{print $3}')"
-
-        rotation="rotation $trans_piece"
-
-        file1="$(ls cubes | grep "move_.*_${move1}.txt")"
-        file2="$(ls cubes | grep "move_.*_${move2}.txt")"
-        echo "$rotation" >"$outdir/${i}_${trans_piece}r_${move1}.in"
-        cat "cubes/$file1" >>"$outdir/${i}_${trans_piece}r_${move1}.in"
-        cp "cubes/$file2" "$outdir/${i}_${trans_piece}r_${move1}.out"
-
-        i=$((i+1))
-
-        mirrored="mirrored $trans_piece"
-        move2m="$(echo "${move2}" | tr 'LR' 'RL')3"
-
-        file1="$(ls cubes | grep "move_.*_${move1}.txt")"
-        file2="$(ls cubes | grep "move_.*_${move2m}.txt")"
-        echo "$mirrored" >"$outdir/${i}_${trans_piece}m_${move1}.in"
-        cat "cubes/$file1" >>"$outdir/${i}_${trans_piece}m_${move1}.in"
-        cp "cubes/$file2" "$outdir/${i}_${trans_piece}m_${move1}.out"
-
-        i=$((i+1))
-done <transform_moves.txt
diff --git a/utils/h48_to_lst.c b/utils/h48_to_lst.c
deleted file mode 100644
index 03265b7..0000000
--- a/utils/h48_to_lst.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-#include <inttypes.h>
-#include <stdbool.h>
-
-#include "../src/nissy.h"
-
-#define STRLENMAX 1000
-
-int main(void) {
-        char strin[STRLENMAX], strout[STRLENMAX];
-        int result;
-
-        fgets(strin, STRLENMAX, stdin);
-
-        result = nissy_convertcube("H48", "LST", strin, strout);
-        if (result)
-                fprintf(stderr, "Error converting cube: code %d\n", result);
-
-        fputs(strout, stdout);
-
-        return 0;
-}
diff --git a/utils/invert.c b/utils/invert.c
deleted file mode 100644
index 41580c0..0000000
--- a/utils/invert.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-#include <inttypes.h>
-#include <stdbool.h>
-
-#include "../src/nissy.h"
-
-#define STRLENMAX 1000
-
-int main(void) {
-        char str[STRLENMAX], cube[22], inv[22];
-
-        fgets(str, STRLENMAX, stdin);
-        nissy_readcube("H48", str, cube);
-        nissy_inverse(cube, inv);
-        nissy_writecube("H48", inv, str);
-        fputs(str, stdout);
-
-        return 0;
-}
diff --git a/utils/mirror.sh b/utils/mirror.sh
deleted file mode 100755
index 41a434f..0000000
--- a/utils/mirror.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/sh
-
-tr 'LR' 'RL'