Symcoord version of nissy. Interesting idea, but performance are actually slower. AT THIS STAGE NISSY IS NOT USABLE. - nissy

commit a125e69c8ce0a2764b1e50b2dad0a4fa9d141ef4
parent 072c52f9a54144bc9a58cf2855d5b582f8ba7a1a
Author: Sebastiano Tronto <sebastiano@tronto.net>
Date:   Tue,  6 Sep 2022 18:00:40 +0200

Symcoord version of nissy. Interesting idea, but performance are
actually slower. AT THIS STAGE NISSY IS NOT USABLE.

Diffstat:
M Makefile  | 5 ++---
M TODO.md  | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------
D doc/nissy.1  | 271 -------------------------------------------------------------------------------
A old/maybe-useful-coord.c  | 181 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A old/maybe-useful-steps.c  | 1111 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M src/alg.c  | 105 ++++++++++++++++++++++++++++---------------------------------------------------
M src/alg.h  | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
M src/commands.c  | 324 +++++++++++++++----------------------------------------------------------------
M src/commands.h  | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
M src/coord.c  | 992 ++++++++++++++++++++++++++++++++++++++++++-------------------------------------
M src/coord.h  | 246 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
M src/cube.c  | 920 +++++++------------------------------------------------------------------------
M src/cube.h  | 44 +++++++++-----------------------------------
M src/cubetypes.h  | 176 +++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/env.c  | 2 ++
M src/env.h  | 4 ++--
M src/moves.c  | 409 ++++++++++++++-----------------------------------------------------------------
M src/moves.h  | 20 ++------------------
D src/pf.c  | 95 -------------------------------------------------------------------------------
D src/pf.h  | 20 --------------------
M src/pruning.c  | 265 ++++++++++++++++++++++++-------------------------------------------------------
M src/pruning.h  | 21 +++++----------------
M src/shell.c  | 22 +++++++++++++++++++++-
M src/solve.c  | 485 ++++++++++++++++++++++++++++++++++++++-----------------------------------------
M src/solve.h  | 4 ++--
M src/steps.c  | 1514 +++++++------------------------------------------------------------------------
M src/steps.h  | 276 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
D src/symcoord.c  | 687 -------------------------------------------------------------------------------
D src/symcoord.h  | 17 -----------------
M src/trans.c  | 383 +++++++++++++++++++++----------------------------------------------------------
M src/trans.h  | 36 +++++++++++++++++++++---------------
M src/utils.c  | 14 ++++++++------
M www/download/index.html  | 2 +-
M www/examples/index.html  | 2 +-
M www/index.html  | 2 +-
A www/style-2.css  | 105 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
D www/style.css  | 99 -------------------------------------------------------------------------------

37 files changed, 3704 insertions(+), 5536 deletions(-)
diff --git a/Makefile b/Makefile
@@ -1,6 +1,6 @@
 # See LICENSE file for copyright and license details.
 
-VERSION = 2.0.2
+VERSION = post-2.0.2
 
 PREFIX = /usr/local
 MANPREFIX = ${PREFIX}/share/man
@@ -26,8 +26,7 @@ debug:
 	${CC} ${DBGFLAGS} -o nissy src/*.c
 
 clean:
-	rm -rf nissy nissy*.exe nissy*.tar.gz
-	rm doc/nissy.html doc/nissy.pdf
+	rm -rf nissy nissy*.exe nissy*.tar.gz doc/nissy.html doc/nissy.pdf
 
 dist: clean nissy.exe
 	mkdir -p nissy-${VERSION}
diff --git a/TODO.md b/TODO.md
@@ -3,50 +3,48 @@
 This is a list of things that I would like to add or change at some point.
 It's more of a personal reminder than anything else.
 
-## Version 2.0.2
-### Website
-* now gen takes 40 minutes
-### Changelog
-* Only improved table generation speed, but this required huge changes in
-  coordinates.c and symcoord.c (+ some minor changes in other parts).
-
 ## For version 2.1
-### Coordinates
-* Text (README.md) description of coordinate system with 3 (or 4) types of
-  coordinates: basic (+ fundamental), sym, composite (consisting of at most
-  one sym + one or more basic)
-* Use this to restructure the coordinate part; maybe fundamental coordinates
-  do not need to exist???
-* Add also "transform" for every coordinate. For example, for EO and similar
-  only allow transformations that fix the EO axis.
-* Also: "basic" symcoord do not allow trans, composite coordinates assume
-  the transformation fixes the basic sumcoord
-* For each coordinate, manually disallow "bad" moves, or just ignore the error
-  (probably better to check: low performance cost, detect problems that I might
-  be overlooking)
+### Slow: it is slower than the old nissy 2.0.2 :(
+* nxopt's trick (switching to reduce branching) actually saves about 50%!
+* Another factor is estimating *while* moving (i.e. do not move all
+  coordinates if the first one already gives a high value!)
+* simplify solve, remove everything that is used only by optimal solvers
+* Good compromise: each stepalt offers one of two alternatives: either solve
+  by simply using pruning tables and moving coordinates, or using a custom
+  estimator and moving a cube (or fast_cube) and computing coordinates
+  in the estimator
+* is there really no way to use inverse branching trick with current system?
+* new file optimal.c with the old solve logic; try first with the simple
+  cube implementation and the new indexers, if it is still slow change
+  to fast_cube (intermediate nissy v2.0.2 implementation)
 ### Changes to Step and Solve
-* Revolutionize: do everything based on coordinates, replace Cube with
-  CubeArray (or just 4 values, so consistency check is super easy);
-  remove tables for fast inverse.
-* No need for most of step data: just solve a list of coordinates
-  (+ associated pruning tables)
-* For steps that accept multiple solved states (e.g. drany):
-  just find a way to "merge" multiple steps as alternatives; or
-  offer multiple lists of coordinates as alternatives
-* De Bondt's trick: list of 3 coords (as indexes in coord array of the step)
-  that if evaluated to the same pruning value allow for de bondt's trick.
-* NISS: compute inverse based on current use moves just before switching,
-  using CubeArray; it is not too slow.
-### Loading at startup vs dynamically
-* Consider moving more things to the initial loading phase (i.e. remove
-  many of the "initialized" parts)
+* remove cube from dfsarg? (i still need to save the scramble somewhere,
+  but I really only use it in dfs_niss)
+* coord.c: all old coordinates (WIP...)
+* steps.c: checkers (use coordinates), all stepalt and steps (WIP...)
+* commands gen and freemem
+* commands.c: twophase, ...?
+* Coordinate should have a moveset field? No, at worst there are some garbage 
+  values in mtable, but no risk for errors
+### Rotate, not transform, before solving
+* solve should re-orient first if needed and not just give up if centers are off
 ### Documentation
+* Document how coordinates and pruning tables work now
 * Write an examples.md file
 * More screenshots!
 ### Tables management
-* Check files in tables directory, add command to remove old / extraneous files
+* Check files in tables directory automatically remove old / extraneous files
 * Add checksum to check that tables are generated / downloaded correctly
-* Edit download page update instructions to tell what to do when changing tables
+### Conditional compiling
+* Option to avoid large tables at compile time
+* option to avoid multithreading (write a simpler solve for t=1, and also
+  check if found enough solutions before checking pruning values)
+### Technical
+* generic option parser
+* testing? Maybe just hardcode some examples generated with old nissy
+### Commands
+* Easy: add option -I (inverse) and -L (linear, like inverse + normal)
+  to do only linear NISS
 
 ## Commands
 
@@ -62,16 +60,21 @@ including e.g. solutions that were not shown because -c)
 * 5-side solve (for robots)
 * Block-building steps (cross, roux blocks, ...)
 * Other common steps (LSE, ...)
+* Larger table for drudfin (include epe)? About 1Gb uncompressed,
+  500Mb compressed (fallback to noE), 250 compressed + parity trick
+  (is it doable?)
 
 ### Improvements to currently implemented commands
-* solve should re-orient first if needed and not just give up if centers are off
+* solve multidfs: do multithread by step, not by alternative (this way
+  if there are multiple alternatives it can make use of more threads)
 * solve should try up to a small bound without loading the large pruning table
+  (maybe this is not necessary if loading the table is fast enough)
 * silent batch mode without >>>
 
 ### New features
+* EO analysis (and also DR and HTR analysis): group similar EOs together
+  and such (suggested by Jay)
 * configurability: add an `alias` command, run config file at startup
-* configure max ram to be used (via config file and/or command line option)
-* transform alg, rufify etc...
 * command notation to list available moves
 * make multi-step solve much more general and create command
 * input directly cube status instead of moves
@@ -105,7 +108,35 @@ including e.g. solutions that were not shown because -c)
 
 ### Cleanup
 * sort again functions alphabetically in their files
+* change some function and variable names to make everything consistent
 * more stuff to load at start (or when suitable command is called) rather
   than when called directly, to avoid nasty problems with threading
 * parse command args: one function per arg type, then each command has
   a list of options that it accepts (as a string)
+
+### Style
+* do not declare all variables at the beginning of a function
+* remove var names from prototypes
+* various stuff from style(9)
+
+### Random
+Collect random info like this somewhere:
+
+Table pt_nxopt31_HTM
+Base value: 9
+0               1
+1               6
+2              29
+3             164
+4            1433
+5           16772
+6          205033
+7         2513871
+8        30329976
+9       342440769
+10     2815191126
+11     6147967200
+12      524918774
+13           3546
+14              0
+15              0
diff --git a/doc/nissy.1 b/doc/nissy.1
@@ -1,271 +0,0 @@
-.Dd November 2021
-.Dt NISSY 1
-.Os
-.Sh NAME
-.Nm nissy
-.Nd a Rubik's cube solver and FMC assistant
-.
-.Sh SYNOPSIS
-.Nm
-.Op Fl b
-.Nm
-.Ar command
-.Op options...
-.
-.Sh DESCRIPTION
-.Nm
-is a Rubik's Cube solver. 
-It uses techniques from Herbert Kociemba's Cube Explorer and
-Tomas Rokicki's nxopt. With 4 cores at 2.5GHz and using about 3Gb
-of RAM, Nissy can find the optimal solution for a random Rubik's cube position
-in about a minute on average.
-Nissy can also solve different substeps of the Thistlethwaite's algorithm and more.
-.Pp
-When run without any argument an interactive shell is launched, otherwise
-the provided
-.Ar command
-is executed and nissy terminates. If the option
-.Fl b
-is given, every argument after it is ignored and the shell is launched without
-any prompt or welcome message. This can be used to run nissy in batch mode,
-for example writing a list of commands in a
-.Ar file
-(one per line) and running
-.Ar nissy -b < file
-.Pp
-The commands that can be run in the interactive shell are the same that can
-be run non-interactively and are provided below.
-.
-.Sh COMMANDS
-The available
-.Ar commands
-are the following:
-.
-.Bl -tag -width Ds
-.
-.It Nm cleanup Ar scramble
-Rewrites the given scramble using only the 18 base (HTM) moves and at most two
-rotations at the end. If
-Ar scramble
-uses NISS, all moves done on normal scramble are written first, followed by
-all moves done on inverse.
-.
-.It Nm commands
-List all available commands.
-.
-.It Nm freemem
-Release some large tables from memory. You can use this command in case
-you want to keep nissy open without using too much RAM.
-.
-.It Nm gen Op Fl t Ar N
-Generate all tables used by nissy. Run this to complete your installation.
-If
-.Ar N
-is specified,
-.Ar N
-CPU threads will be used (defaults to 64, use less only if you don't want
-nissy to use all of your CPU resources).
-.
-.It Nm help Op Ar command
-Display help. If no
-.Ar command
-is given, a generic help message is printed, otherwise a specific help
-relative to
-.Ar command
-is returned.
-.
-.It Nm invert Ar scramble
-Invert the given scramble.
-.
-.It Nm print Ar scramble
-Display a text-only description of the cube obtained after applying
-.Ar scramble .
-.
-.It Nm quit
-Quit nissy.
-.
-.It Nm scramble Oo Fl n Ar N Oc Oo Ar type Oc
-Print a randomly-generated (random position) scramble
-.
-If
-.Ar N
-is given, it produces
-.Ar N
-scrambles.
-.Ar type
-can be specified to be one of the following:
-.Bl -tag -width Ds
-.It Ar corners
-Scramble with solved edges (only cornes are scrambled).
-.It Ar dr
-Scramble with solved DR on U/D.
-.It Ar edges
-Scramble with solved corners (only edges are scrambled).
-.It Ar eo
-Scramble with solved EO on F/B axis.
-.It Ar fmc
-Scramble the full cube and the resulting scramble starts and ends with
-the moves R\(aq U\(aq F.
-.It Ar htr
-Scramble with HTR solved.
-.El
-.
-.It Nm solve Ar step Oo Ar options Oc Ar scramble
-Solve the given
-.Ar step
-on the given
-.Ar scramble.
-By default it finds only one (shortest) solution, without using niss, and it
-displays the number of moves at the end of the line.
-.
-The options for the
-.Ar solve
-command are the following:
-.
-.Bl -tag -width Ds
-.
-.It Fl a
-Print all solutions: some solutions are filtered out by default for some
-steps, for examples EOs that finish with F\(aq, with this options they are not.
-.
-.It Fl c
-Display only the number of solutions found, not the solutions themselves.
-.
-.It Fl m Ar min
-Only look for solution that are at least
-.Ar min
-moves long.
-.
-.It Fl M Ar MAX
-Only look for solution that are at most
-.Ar MAX
-moves long.
-.
-.It Fl n Ar N
-Try to find
-.Ar N
-solutions. By default and unless the
-.Fl M
-or
-.Fl o
-options are used, at most one solution is returned. 
-If at least one of
-.Fl M
-and
-.Fl o
-is used, all the solutions found within the given bounds are returned.
-The option
-.Fl s
-overwrites these default behaviors and at most
-.Ar N
-solutions are returned, still satisfiyng the other constraints.
-.
-.It Fl N
-Allow use of NISS.
-.
-.It Fl o
-Only find solutions that require the minimum number of moves.
-.
-.It Fl O Ar N
-Only find solutions that require at most
-.Ar N
-moves more than the optimal solution. If
-.Ar N
-is 0, this is equivalent to
-.Fl o
-.
-.It Fl p
-Plain style: do not print the number of moves.
-.
-.It Fl t Ar N
-Use
-.Ar N
-CPU threads. By default nissy uses only 1 thread. Using more than one
-thread will improve performance, but the optimal number depends on your
-machine and operating system. Generally, using one less than the number
-of threads of your CPU works quite well.
-.
-.It Fl v
-Verbose mode: print some information during the search and print each solution
-as it is found instead of only printing them all together at the end.
-.
-.
-.El
-.
-.It Nm steps
-List all available
-.Ar steps
-for the
-.Ar solve
-command.
-.
-.It Nm twophase Ar scramble
-Find a solution using a two-phase method. This does not guarantee
-to return an optimal solution (and in fact most often it does not),
-but it is very fast.
-.
-.It Nm unniss Ar scramble
-Rewrite the scramble without using NISS.
-.
-.It Nm version
-Display version information.
-.
-.El
-.
-.Sh SCRAMBLES
-All the commands above that accept a scramble also accept a
-.Fl Nm i
-option with no arguments.
-If this option is given, multiple scrambles are read from standard
-input (one per line) until and EOF is found, at which point stdin is cleared.
-.
-.Sh ENVIRONMENT
-Data is stored in the folder pointed to by
-.Nm $NISSYDATA.
-If that variable is unset the folder
-.Nm $XDG_DATA_HOME/nissy
-or
-.Nm $HOME/.nissy
-is used instead. If none of this environment variables is defined
-(e.g. in a non-UNIX system), the current folder is used.
-.
-.Sh EXAMPLES
-.Pp
-The command:
-.Dl nissy solve -v -O 1 \(dqR\(aqU\(aqFD2L2FR2U2R2BD2LB2D\(aqB2L\(aqR\(aqBD2BU2LU2R\(aqU\(aqF\(dq
-Returns:
-.Dl Searching depth 0
-.Dl Searching depth 1
-.Dl (some more lines)
-.Dl Searching depth 16
-.Dl D2 F\(aq U2 D2 F\(aq L2 D R2 D F B2 R\(aq L2 F\(aq U\(aq D
-.Dl Searching depth 17
-.Dl D2 F\(aq U2 D2 F\(aq L2 D R2 D F B2 R\(aq L2 F\(aq U\(aq D (16)
-Notice that the solution is printed twice: the first time it is printed as soon
-as it is found as requested by the -v option.
-.Pp
-The command:
-.Dl nissy solve eofb -m 4 -M 5 -N -n 6 \(dqR\(aqU\(aqFD2L2 FR2 U2R2BD2 L B2 D\(aq B2 L\(aq R\(aq\(dq
-Returns:
-.Dl U B U\(aq B (4)
-.Dl U (B R\(aq B) (4)
-.Dl (U B R\(aq B) (4)
-.Dl U2 F R2 F (4)
-.Dl U2 B U2 B (4)
-.Dl (U2 B R\(aq B) (4)
-.Pp
-On a UNIX shell, the composite command
-.Dl nissy scramble -n 2 | nissy solve -i > file.txt
-Generates two random scrambles, solves them and saves the result to file.txt.
-The file will look something like this:
-.Dl >>> Line: D U2 F D B\(aq F L2 D\(aq F2 R2 L B2 L\(aq U2 B2 R F2 L\(aq D2
-.Dl U2 R2 F2 L B2 D\(aq R2 D\(aq F U L2 B\(aq U\(aq R2 D2 R2 U (17)
-.Dl >>> Line: D B R U\(aq B\(aq L2 U L U D2 R L B2 U2 L2 U2 R U2 B2 L F2
-.Dl D\(aq F R\(aq D B L2 B R2 L U L U2 B D\(aq U R U F2 (18)
-.
-.Sh AUTHORS
-.An Sebastiano Tronto Aq Mt sebastiano@tronto.net
-.
-.Sh SOURCE CODE
-Source code is available at
-.Lk https://nissy.tronto.net
diff --git a/old/maybe-useful-coord.c b/old/maybe-useful-coord.c
@@ -0,0 +1,181 @@
+int
+array_ep_to_epos(int *ep, int *ss)
+{
+	int epos[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+	int eps[4];
+	int i, j, is;
+
+	for (i = 0, is = 0; i < 12; i++) {
+		for (j = 0; j < 4; j++) {
+			if (ep[i] == ss[j]) {
+				eps[is++] = j;
+				epos[i] = 1;
+			}
+		}
+	}
+
+	for (i = 0; i < 4; i++)
+		swap(&epos[ss[i]], &epos[i+8]);
+
+	return 24 * subset_to_index(epos, 12, 4) + perm_to_index(eps, 4);
+}
+
+void
+epos_to_compatible_ep(int epos, int *ep, int *ss)
+{
+	int i, j, k, other[8];
+	bool flag;
+
+	for (i = 0; i < 12; i++)
+		ep[i] = -1;
+
+	epos_to_partial_ep(epos, ep, ss);
+
+	for (i = 0, j = 0; i < 12; i++) {
+		flag = false;
+		for (k = 0; k < 4; k++)
+			flag = flag || (i == ss[k]);
+		if (!flag)
+			other[j++] = i;
+	}
+		
+	for (i = 0, j = 0; i < 12; i++)
+		if (ep[i] == -1)
+			ep[i] = other[j++];
+}
+
+void
+epos_to_partial_ep(int epos, int *ep, int *ss)
+{
+	int i, is, eposs[12], eps[4];
+
+	index_to_perm(epos % FACTORIAL4, 4, eps);
+	index_to_subset(epos / FACTORIAL4, 12, 4, eposs);
+
+	for (i = 0; i < 4; i++)
+		swap(&eposs[ss[i]], &eposs[i+8]);
+
+	for (i = 0, is = 0; i < 12; i++)
+		if (eposs[i])
+			ep[i] = ss[eps[is++]];
+}
+
+void
+fix_eorleoud(CubeArray *arr)
+{
+	int i;
+
+	for (i = 0; i < 12; i++) {
+		if ((edge_slice(i) == 0 && edge_slice(arr->ep[i]) != 0) ||
+		    (edge_slice(i) != 0 && edge_slice(arr->ep[i]) == 0)) {
+			arr->eorl[i] = 1 - arr->eofb[i];
+		} else {
+			arr->eorl[i] = arr->eofb[i];
+		}
+
+		if ((edge_slice(i) == 2 && edge_slice(arr->ep[i]) != 2) ||
+		    (edge_slice(i) != 2 && edge_slice(arr->ep[i]) == 2)) {
+			arr->eoud[i] = 1 - arr->eofb[i];
+		} else {
+			arr->eoud[i] = arr->eofb[i];
+		}
+	}
+}
+
+void
+fix_cofbcorl(CubeArray *arr)
+{
+	int i;
+
+	for (i = 0; i < 8; i++) {
+		if (i % 2 == arr->cp[i] % 2) {
+			arr->cofb[i] = arr->coud[i];
+			arr->corl[i] = arr->coud[i];
+		} else {
+			if (arr->cp[i] % 2 == 0) {
+				arr->cofb[i] = (arr->coud[i]+1)%3;
+				arr->corl[i] = (arr->coud[i]+2)%3;
+			} else {
+				arr->cofb[i] = (arr->coud[i]+2)%3;
+				arr->corl[i] = (arr->coud[i]+1)%3;
+			}
+		}
+	}
+}
+
+Cube
+admissible_ep(Cube cube, PieceFilter f)
+{
+	CubeArray *arr = new_cubearray(cube, f);
+	Cube ret;
+	bool used[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+	int i, j;
+
+	for (i = 0; i < 12; i++)
+		if (arr->ep[i] != -1)
+			used[arr->ep[i]] = true;
+
+	for (i = 0, j = 0; i < 12; i++) {
+		for ( ; j < 11 && used[j]; j++);
+		if (arr->ep[i] == -1)
+			arr->ep[i] = j++;
+	}
+
+	ret = arrays_to_cube(arr, pf_ep);
+	free_cubearray(arr, f);
+
+	return ret;
+}
+
+int
+edge_slice(Edge e) {
+	if (e < 0 || e > 11)
+		return -1;
+
+	if (e == FR || e == FL || e == BL || e == BR)
+		return 0;
+	if (e == UR || e == UL || e == DR || e == DL)
+		return 1;
+
+	return 2;
+}
+
+int
+piece_orientation(Cube cube, int piece, char *orientation)
+{
+	int arr[12], n, b, x;
+
+	if (!strcmp(orientation, "eofb")) {
+		x = cube.eofb;
+		n = 12;
+		b = 2;
+	} else if (!strcmp(orientation, "eorl")) {
+		x = cube.eorl;
+		n = 12;
+		b = 2;
+	} else if (!strcmp(orientation, "eoud")) {
+		x = cube.eoud;
+		n = 12;
+		b = 2;
+	} else if (!strcmp(orientation, "coud")) {
+		x = cube.coud;
+		n = 8;
+		b = 3;
+	} else if (!strcmp(orientation, "corl")) {
+		x = cube.corl;
+		n = 8;
+		b = 3;
+	} else if (!strcmp(orientation, "cofb")) {
+		x = cube.cofb;
+		n = 8;
+		b = 3;
+	} else {
+		return -1;
+	}
+
+	int_to_sum_zero_array(x, b, n, arr);
+	if (piece < n)
+		return arr[piece];
+
+	return -1;
+}
diff --git a/old/maybe-useful-steps.c b/old/maybe-useful-steps.c
@@ -0,0 +1,1111 @@
+#include "steps.h"
+
+#define UPDATECHECKSTOP(a, b, c)     if ((a=(MAX((a),(b))))>(c)) return (a);
+
+static int              estimate_stepalt(StepAlt *a, uint64_t *ind);
+
+/* Checkers and validators ***************************************************/
+
+/* TODO: these should be with Cube *cube (and all need to change) */
+/* Maybe move them to cube.c */
+static bool             check_centers(Cube cube);
+static bool             check_coud_HTM(Cube cube);
+static bool             check_coud_URF(Cube cube);
+static bool             check_corners_HTM(Cube cube);
+static bool             check_corners_URF(Cube cube);
+static bool             check_cornershtr(Cube cube);
+static bool             check_eofb(Cube cube);
+static bool             check_drud(Cube cube);
+static bool             check_htr(Cube cube);
+
+static bool             always_valid(Alg *alg);
+static bool             validate_singlecw_ending(Alg *alg);
+
+/* Messages for when cube is not ready ***************************************/
+
+static char check_centers_msg[100] = "cube must be oriented (centers solved)";
+static char check_eo_msg[100]      = "EO must be solved on given axis";
+static char check_dr_msg[100]      = "DR must be solved on given axis";
+static char check_htr_msg[100]     = "HTR must be solved";
+static char check_drany_msg[100]   = "DR must be solved on at least one axis";
+
+/* Steps *********************************************************************/
+
+/* Optimal solvers *******************/
+
+Step
+optimal_HTM = {
+	.shortname = "optimal",
+	.name      = "Optimal solve (in HTM)",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_nxopt31_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
+	.ntables   = 2,
+};
+
+Step
+optimal_light_HTM = {
+	.shortname = "light",
+	.name      = "Optimal solve (in HTM), small table (500Mb RAM total)",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_light_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_drud_sym16_HTM, &pd_corners_HTM},
+	.ntables   = 2,
+};
+
+/* Optimal after EO ******************/
+
+Step
+eofin_eo = {
+	.shortname = "eofin",
+	.name      = "Optimal solve after EO without breaking EO (detected)",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_nxopt31_HTM,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_eofb,
+
+	.detect    = detect_pretrans_eofb,
+
+	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
+	.ntables   = 2,
+};
+
+Step
+eofbfin_eofb = {
+	.shortname = "eofbfin",
+	.name      = "Optimal after EO on F/B without breaking EO",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_nxopt31_HTM,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
+	.ntables   = 2,
+};
+
+Step
+eorlfin_eorl = {
+	.shortname = "eorlfin",
+	.name      = "Optimal after EO on R/L without breaking EO",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_nxopt31_HTM,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = ur,
+
+	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
+	.ntables   = 2,
+};
+
+Step
+eoudfin_eoud = {
+	.shortname = "eoudfin",
+	.name      = "Optimal after EO on U/D without breaking EO",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_nxopt31_HTM,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
+	.ntables   = 2,
+};
+
+/* EO steps **************************/
+Step
+eoany_HTM = {
+	.shortname = "eo",
+	.name      = "EO on any axis",
+
+	.final     = false,
+	.is_done   = check_eofb,
+	.estimate  = estimate_eofb_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.detect    = detect_pretrans_void_3axis,
+
+	.tables    = {&pd_eofb_HTM},
+	.ntables   = 1,
+};
+
+Step
+eofb_HTM = {
+	.shortname = "eofb",
+	.name      = "EO on F/B",
+
+	.final     = false,
+	.is_done   = check_eofb,
+	.estimate  = estimate_eofb_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_eofb_HTM},
+	.ntables   = 1,
+};
+
+Step
+eorl_HTM = {
+	.shortname = "eorl",
+	.name      = "EO on R/L",
+
+	.final     = false,
+	.is_done   = check_eofb,
+	.estimate  = estimate_eofb_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = ur,
+
+	.tables    = {&pd_eofb_HTM},
+	.ntables   = 1,
+};
+
+Step
+eoud_HTM = {
+	.shortname = "eoud",
+	.name      = "EO on U/D",
+
+	.final     = false,
+	.is_done   = check_eofb,
+	.estimate  = estimate_eofb_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_eofb_HTM},
+	.ntables   = 1,
+};
+
+/* CO steps **************************/
+Step
+coany_HTM = {
+	.shortname = "co",
+	.name      = "CO on any axis",
+
+	.final     = false,
+	.is_done   = check_coud_HTM,
+	.estimate  = estimate_coud_HTM,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.detect    = detect_pretrans_void_3axis,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+coud_HTM = {
+	.shortname = "coud",
+	.name      = "CO on U/D",
+
+	.final     = false,
+	.is_done   = check_coud_HTM,
+	.estimate  = estimate_coud_HTM,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+corl_HTM = {
+	.shortname = "corl",
+	.name      = "CO on R/L",
+
+	.final     = false,
+	.is_done   = check_coud_HTM,
+	.estimate  = estimate_coud_HTM,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = rf,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+cofb_HTM = {
+	.shortname = "cofb",
+	.name      = "CO on F/B",
+
+	.final     = false,
+	.is_done   = check_coud_HTM,
+	.estimate  = estimate_coud_HTM,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+coany_URF = {
+	.shortname = "co-URF",
+	.name      = "CO any axis (URF moveset)",
+
+	.final     = false,
+	.is_done   = check_coud_URF,
+	.estimate  = estimate_coud_URF,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_URF,
+
+	.detect    = detect_pretrans_void_3axis,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+coud_URF = {
+	.shortname = "coud-URF",
+	.name      = "CO on U/D (URF moveset)",
+
+	.final     = false,
+	.is_done   = check_coud_URF,
+	.estimate  = estimate_coud_URF,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_URF,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+corl_URF = {
+	.shortname = "corl-URF",
+	.name      = "CO on R/L (URF moveset)",
+
+	.final     = false,
+	.is_done   = check_coud_URF,
+	.estimate  = estimate_coud_URF,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_URF,
+
+	.pre_trans = rf,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+Step
+cofb_URF = {
+	.shortname = "cofb-URF",
+	.name      = "CO on F/B (URF moveset)",
+
+	.final     = false,
+	.is_done   = check_coud_URF,
+	.estimate  = estimate_coud_URF,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_URF,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_coud_HTM},
+	.ntables   = 1,
+};
+
+/* Misc corner steps *****************/
+Step
+cornershtr_HTM = {
+	.shortname = "chtr",
+	.name      = "Solve corners to HTR state",
+
+	.final     = false,
+	.is_done   = check_cornershtr,
+	.estimate  = estimate_cornershtr_HTM,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_cornershtr_HTM},
+	.ntables   = 1,
+};
+
+Step
+cornershtr_URF = {
+	.shortname = "chtr-URF",
+	.name      = "Solve corners to HTR state (URF moveset)",
+
+	.final     = false,
+	.is_done   = check_cornershtr,
+	.estimate  = estimate_cornershtr_URF,
+	.ready     = NULL,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_URF,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_cornershtr_HTM},
+	.ntables   = 1,
+};
+
+Step
+corners_HTM = {
+	.shortname = "corners",
+	.name      = "Solve corners",
+
+	.final     = true,
+	.is_done   = check_corners_HTM,
+	.estimate  = estimate_corners_HTM,
+	.ready     = NULL,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_corners_HTM},
+	.ntables   = 1,
+};
+
+Step
+corners_URF = {
+	.shortname = "corners-URF",
+	.name      = "Solve corners (URF moveset)",
+
+	.final     = true, /* TODO: check if this works with reorient */
+	.is_done   = check_corners_URF,
+	.estimate  = estimate_corners_URF,
+	.ready     = NULL,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_URF,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_corners_HTM},
+	.ntables   = 1,
+};
+
+/* DR steps **************************/
+Step
+drany_HTM = {
+	.shortname = "dr",
+	.name      = "DR on any axis",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.detect    = detect_pretrans_void_3axis,
+
+	.tables    = {&pd_drud_sym16_HTM},
+	.ntables   = 1,
+};
+
+Step
+drud_HTM = {
+	.shortname = "drud",
+	.name      = "DR on U/D",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_drud_sym16_HTM},
+	.ntables   = 1,
+};
+
+Step
+drrl_HTM = {
+	.shortname = "drrl",
+	.name      = "DR on R/L",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = rf,
+
+	.tables    = {&pd_drud_sym16_HTM},
+	.ntables   = 1,
+};
+
+Step
+drfb_HTM = {
+	.shortname = "drfb",
+	.name      = "DR on F/B",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_HTM,
+	.ready     = check_centers,
+	.ready_msg = check_centers_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_HTM,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_drud_sym16_HTM},
+	.ntables   = 1,
+};
+
+/* DR from EO */
+Step
+dr_eo = {
+	.shortname = "dr-eo",
+	.name      = "DR without breaking EO (automatically detected)",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_dr_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.detect    = detect_pretrans_eofb,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+dr_eofb = {
+	.shortname = "dr-eofb",
+	.name      = "DR on U/D or R/L without breaking EO on F/B",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_dr_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+dr_eorl = {
+	.shortname = "dr-eorl",
+	.name      = "DR on U/D or F/B without breaking EO on R/L",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_dr_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = ur,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+dr_eoud = {
+	.shortname = "dr-eoud",
+	.name      = "DR on R/L or F/B without breaking EO on U/D",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_dr_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+drud_eofb = {
+	.shortname = "drud-eofb",
+	.name      = "DR on U/D without breaking EO on F/B",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+drrl_eofb = {
+	.shortname = "drrl-eofb",
+	.name      = "DR on R/L without breaking EO on F/B",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = rf,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+drud_eorl = {
+	.shortname = "drud-eorl",
+	.name      = "DR on U/D without breaking EO on R/L",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = ur,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+drfb_eorl = {
+	.shortname = "drfb-eorl",
+	.name      = "DR on F/B without breaking EO on R/L",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = fr,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+drfb_eoud = {
+	.shortname = "drfb-eoud",
+	.name      = "DR on F/B without breaking EO on U/D",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+Step
+drrl_eoud = {
+	.shortname = "drrl-eoud",
+	.name      = "DR on R/L without breaking EO on U/D",
+
+	.final     = false,
+	.is_done   = check_drud,
+	.estimate  = estimate_drud_eofb,
+	.ready     = check_eofb,
+	.ready_msg = check_eo_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_eofb,
+
+	.pre_trans = rd,
+
+	.tables    = {&pd_drud_eofb},
+	.ntables   = 1,
+};
+
+/* DR finish steps */
+Step
+dranyfin_DR = {
+	.shortname = "drfin",
+	.name      = "DR finish on any axis without breaking DR",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_drudfin_drud,
+	.ready     = check_drud,
+	.ready_msg = check_drany_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_drud,
+
+	.detect    = detect_pretrans_drud,
+
+	.tables    = {&pd_drudfin_noE_sym16_drud},
+	.ntables   = 1,
+};
+
+Step
+drudfin_drud = {
+	.shortname = "drudfin",
+	.name      = "DR finish on U/D without breaking DR",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_drudfin_drud,
+	.ready     = check_drud,
+	.ready_msg = check_dr_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_drud,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_drudfin_noE_sym16_drud},
+	.ntables   = 1,
+};
+
+Step
+drrlfin_drrl = {
+	.shortname = "drrlfin",
+	.name      = "DR finish on R/L without breaking DR",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_drudfin_drud,
+	.ready     = check_drud,
+	.ready_msg = check_dr_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_drud,
+
+	.pre_trans = rf,
+
+	.tables    = {&pd_drudfin_noE_sym16_drud},
+	.ntables   = 1,
+};
+
+Step
+drfbfin_drfb = {
+	.shortname = "drfbfin",
+	.name      = "DR finish on F/B without breaking DR",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_drudfin_drud,
+	.ready     = check_drud,
+	.ready_msg = check_dr_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_drud,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_drudfin_noE_sym16_drud},
+	.ntables   = 1,
+};
+
+/* HTR from DR */
+Step
+htr_any = {
+	.shortname = "htr",
+	.name      = "HTR from DR",
+
+	.final     = false,
+	.is_done   = check_htr,
+	.estimate  = estimate_htr_drud,
+	.ready     = check_drud,
+	.ready_msg = check_drany_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_drud,
+
+	.detect    = detect_pretrans_drud,
+
+	.tables    = {&pd_htr_drud},
+	.ntables   = 1,
+};
+
+Step
+htr_drud = {
+	.shortname = "htr-drud",
+	.name      = "HTR from DR on U/D",
+
+	.final     = false,
+	.is_done   = check_htr,
+	.estimate  = estimate_htr_drud,
+	.ready     = check_drud,
+	.ready_msg = check_dr_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_drud,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_htr_drud},
+	.ntables   = 1,
+};
+
+Step
+htr_drrl = {
+	.shortname = "htr-drrl",
+	.name      = "HTR from DR on R/L",
+
+	.final     = false,
+	.is_done   = check_htr,
+	.estimate  = estimate_htr_drud,
+	.ready     = check_drud,
+	.ready_msg = check_dr_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_drud,
+
+	.pre_trans = rf,
+
+	.tables    = {&pd_htr_drud},
+	.ntables   = 1,
+};
+
+Step
+htr_drfb = {
+	.shortname = "htr-drfb",
+	.name      = "HTR from DR on F/B",
+
+	.final     = false,
+	.is_done   = check_htr,
+	.estimate  = estimate_htr_drud,
+	.ready     = check_drud,
+	.ready_msg = check_dr_msg,
+	.is_valid  = validate_singlecw_ending,
+	.moveset   = &moveset_drud,
+
+	.pre_trans = fd,
+
+	.tables    = {&pd_htr_drud},
+	.ntables   = 1,
+};
+
+/* HTR finish */
+Step
+htrfin_htr = {
+	.shortname = "htrfin",
+	.name      = "HTR finish without breaking HTR",
+
+	.final     = true,
+	.is_done   = is_solved,
+	.estimate  = estimate_htrfin_htr,
+	.ready     = check_htr,
+	.ready_msg = check_htr_msg,
+	.is_valid  = always_valid,
+	.moveset   = &moveset_htr,
+
+	.pre_trans = uf,
+
+	.tables    = {&pd_htrfin_htr},
+	.ntables   = 1,
+};
+
+Step *steps[] = {
+	&optimal_HTM, /* first is default */
+	&optimal_light_HTM,
+
+	&eofin_eo,
+	&eofbfin_eofb,
+	&eorlfin_eorl,
+	&eoudfin_eoud,
+
+	&eoany_HTM,
+	&eofb_HTM,
+	&eorl_HTM,
+	&eoud_HTM,
+
+	&coany_HTM,
+	&coud_HTM,
+	&corl_HTM,
+	&cofb_HTM,
+
+	&coany_URF,
+	&coud_URF,
+	&corl_URF,
+	&cofb_URF,
+
+	&drany_HTM,
+	&drud_HTM,
+	&drrl_HTM,
+	&drfb_HTM,
+
+	&dr_eo,
+	&dr_eofb,
+	&dr_eorl,
+	&dr_eoud,
+	&drud_eofb,
+	&drrl_eofb,
+	&drud_eorl,
+	&drfb_eorl,
+	&drfb_eoud,
+	&drrl_eoud,
+
+	&dranyfin_DR,
+	&drudfin_drud,
+	&drrlfin_drrl,
+	&drfbfin_drfb,
+
+	&htr_any,
+	&htr_drud,
+	&htr_drrl,
+	&htr_drfb,
+
+	&htrfin_htr,
+
+	&cornershtr_HTM,
+	&cornershtr_URF,
+	&corners_HTM,
+	&corners_URF,
+
+	NULL
+};
+
+/* Checkers and validators ***************************************************/
+
+static bool
+check_centers(Cube cube)
+{
+	return cube.cpos == 0;
+}
+
+static bool
+check_coud_HTM(Cube cube)
+{
+	return cube.coud == 0;
+}
+
+static bool
+check_coud_URF(Cube cube)
+{
+	Cube c2, c3;
+
+	c2 = apply_move(z, cube);
+	c3 = apply_move(x, cube);
+
+	return cube.coud == 0 || c2.coud == 0 || c3.coud == 0;
+}
+
+static bool
+check_corners_URF(Cube cube)
+{
+	Cube c;
+	Trans i;
+
+	for (i = 0; i < NROTATIONS; i++) {
+		c = apply_alg(rotation_alg(i), cube);
+		if (c.cp && c.coud)
+			return true;
+	}
+
+	return false;
+}
+
+static bool
+check_corners_HTM(Cube cube)
+{
+	return cube.cp == 0 && cube.coud == 0;
+}
+
+static bool
+check_cornershtr(Cube cube)
+{
+	return coord_cornershtr.index(cube) == 0;
+}
+
+static bool
+check_eofb(Cube cube)
+{
+	return cube.eofb == 0;
+}
+
+static bool
+check_drud(Cube cube)
+{
+	return cube.eofb == 0 && cube.eorl == 0 && cube.coud == 0;
+}
+
+static bool
+check_htr(Cube cube)
+{
+	return check_drud(cube) && coord_htr_drud.index(cube) == 0;
+}
+
+static bool
+always_valid(Alg *alg)
+{
+	return true;
+}
+
+static bool
+validate_singlecw_ending(Alg *alg)
+{
+	int i;
+	bool nor, inv;
+	Move l2 = NULLMOVE, l1 = NULLMOVE, l2i = NULLMOVE, l1i = NULLMOVE;
+
+	for (i = 0; i < alg->len; i++) {
+		if (alg->inv[i]) {
+			l2i = l1i;
+			l1i = alg->move[i];
+		} else {
+			l2 = l1;
+			l1 = alg->move[i];
+		}
+	}
+
+	nor = l1 ==base_move(l1)  && (!commute(l1, l2) ||l2 ==base_move(l2));
+	inv = l1i==base_move(l1i) && (!commute(l1i,l2i)||l2i==base_move(l2i));
+
+	return nor && inv;
+}
+
+/* Public functions **********************************************************/
+
+void
+compute_ind(StepAlt *a, Cube *cube, uint64_t *ind)
+{
+
+}
+
+int
+estimate_stepalt(StepAlt *a, uint64_t *ind)
+{
+	int i, ret, est[a->n_coord];
+
+	for (i = 0; i < a->n_coord; i++) {
+		est[i] = ptableval(a->pd[i], ind[i]);
+		if (est[i] == 0 && a->compact_pd[i])
+			est[i] = ptableval(a->fallback_pd, ind[i] / a->fbmod);
+	}
+
+	for (i = 0; i < a->n_dbtrick; i++)
+		if (est[a->dbtrick[i][0]] == est[a->dbtrick[i][1]] &&
+		    est[a->dbtrick[i][0]] == est[a->dbtrick[i][2]])
+			est[a->dbtrick[i][0]] += 1;
+
+	for (i = 0, ret = -1; i < a->n_coord; i++)
+		ret = max(ret, est[i]);
+
+	return ret;
+}
+
+void
+prepare_step(Step *step, SolveOptions *opts)
+{
+	int i, j;
+	PDGenData pdg;
+	StepAlt *a;
+
+	init_moveset(step->moveset);
+	pdg.moveset = step->moveset;
+
+	for (i = 0; step->alt[i] != NULL; i++) {
+		a = step->alt[i];
+		for (j = 0; j < a->n_coord; j++) {
+			gen_coord(a->coord[j]);
+
+			pdg.coord   = a->coord[j];
+			pdg.compact = a->compact[j];
+			pdg.pd      = NULL;
+
+			a->pd[j] = genptable(&pdg, opts->nthreads);
+
+			if (a->compact_pd[j]) {
+				gen_coord(a->fallback_coord[j]);
+
+				pdg.coord   = a->fallback_coord[j];
+				pdg.compact = false;
+				pdg.pd      = NULL;
+
+				a->fallback_pd[j] =
+					step->genptable(&pdg, opts->nthreads);
+			}
+		}
+	}
+}
diff --git a/src/alg.c b/src/alg.c
@@ -1,68 +1,18 @@
-#include "alg.h"
+#define ALG_C
 
-/* Local functions ***********************************************************/
+#include "alg.h"
 
-static bool        allowed_HTM(Move m);
-static bool        allowed_URF(Move m);
-static bool        allowed_eofb(Move m);
-static bool        allowed_drud(Move m);
-static bool        allowed_htr(Move m);
-static bool        allowed_next_HTM(Move l2, Move l1, Move m);
 static int         axis(Move m);
-
 static void        free_alglistnode(AlgListNode *aln);
 static void        realloc_alg(Alg *alg, int n);
 
-/* Movesets ******************************************************************/
-
-Moveset
-moveset_HTM = {
-	.allowed      = allowed_HTM,
-	.allowed_next = allowed_next_HTM,
-};
-
-Moveset
-moveset_URF = {
-	.allowed      = allowed_URF,
-	.allowed_next = allowed_next_HTM,
-};
-
-Moveset
-moveset_eofb = {
-	.allowed      = allowed_eofb,
-	.allowed_next = allowed_next_HTM,
-};
-
-Moveset
-moveset_drud = {
-	.allowed      = allowed_drud,
-	.allowed_next = allowed_next_HTM,
-};
-
-Moveset
-moveset_htr = {
-	.allowed      = allowed_htr,
-	.allowed_next = allowed_next_HTM,
-};
-
-static int nmoveset = 5;
-static Moveset * all_ms[] = {
-	&moveset_HTM,
-	&moveset_URF,
-	&moveset_eofb,
-	&moveset_drud,
-	&moveset_htr,
-};
-
-/* Functions *****************************************************************/
-
-static bool
+bool
 allowed_HTM(Move m)
 {
 	return m >= U && m <= B3;
 }
 
-static bool
+bool
 allowed_URF(Move m)
 {
 	Move b = base_move(m);
@@ -70,7 +20,7 @@ allowed_URF(Move m)
 	return b == U || b == R || b == F;
 }
 
-static bool
+bool
 allowed_eofb(Move m)
 {
 	Move b = base_move(m);
@@ -79,7 +29,7 @@ allowed_eofb(Move m)
 	       ((b == F || b == B) && m == b+1);
 }
 
-static bool
+bool
 allowed_drud(Move m)
 {
 	Move b = base_move(m);
@@ -88,7 +38,7 @@ allowed_drud(Move m)
 	       ((b == R || b == L || b == F || b == B) && m == b + 1);
 }
 
-static bool
+bool
 allowed_htr(Move m)
 {
 	Move b = base_move(m);
@@ -96,8 +46,8 @@ allowed_htr(Move m)
 	return moveset_HTM.allowed(m) && m == b + 1;
 }
 
-static bool
-allowed_next_HTM(Move l2, Move l1, Move m)
+bool
+allowed_next_all(Move l2, Move l1, Move m)
 {
 	bool p, q;
 
@@ -469,6 +419,34 @@ swapmove(Move *m1, Move *m2)
 	*m2 = aux;
 }
 
+char *
+trans_string(Trans t)
+{
+	static char trans_string_aux[NTRANS][20] = {
+		[uf]  = "uf",  [ur]  = "ur", [ub] = "ub", [ul] = "ul",
+		[df]  = "df",  [dr]  = "dr", [db] = "db", [dl] = "dl",
+		[rf]  = "rf",  [rd]  = "rd", [rb] = "rb", [ru] = "ru",
+		[lf]  = "lf",  [ld]  = "ld", [lb] = "lb", [lu] = "lu",
+		[fu]  = "fu",  [fr]  = "fr", [fd] = "fd", [fl] = "fl",
+		[bu]  = "bu",  [br]  = "br", [bd] = "bd", [bl] = "bl",
+
+		[uf_mirror] = "uf*", [ur_mirror] = "ur*",
+		[ub_mirror] = "ub*", [ul_mirror] = "ul*",
+		[df_mirror] = "df*", [dr_mirror] = "dr*",
+		[db_mirror] = "db*", [dl_mirror] = "dl*",
+		[rf_mirror] = "rf*", [rd_mirror] = "rd*",
+		[rb_mirror] = "rb*", [ru_mirror] = "ru*",
+		[lf_mirror] = "lf*", [ld_mirror] = "ld*",
+		[lb_mirror] = "lb*", [lu_mirror] = "lu*",
+		[fu_mirror] = "fu*", [fr_mirror] = "fr*",
+		[fd_mirror] = "fd*", [fl_mirror] = "fl*",
+		[bu_mirror] = "bu*", [br_mirror] = "br*",
+		[bd_mirror] = "bd*", [bl_mirror] = "bl*",
+	};
+
+	return trans_string_aux[t];
+}
+
 Alg *
 unniss(Alg *alg)
 {
@@ -513,12 +491,3 @@ init_moveset(Moveset *ms)
 		}
 	}
 }
-
-void
-init_all_movesets()
-{
-	int i;
-
-	for (i = 0; i < nmoveset; i++)
-		init_moveset(all_ms[i]);
-}
diff --git a/src/alg.h b/src/alg.h
@@ -8,12 +8,13 @@
 #include "cubetypes.h"
 #include "utils.h"
 
-extern Moveset          moveset_HTM;
-extern Moveset          moveset_URF;
-extern Moveset          moveset_eofb;
-extern Moveset          moveset_drud;
-extern Moveset          moveset_htr;
-
+bool        allowed_all(Move m);
+bool        allowed_HTM(Move m);
+bool        allowed_URF(Move m);
+bool        allowed_eofb(Move m);
+bool        allowed_drud(Move m);
+bool        allowed_htr(Move m);
+bool        allowed_next_all(Move l2, Move l1, Move m);
 void        append_alg(AlgList *l, Alg *alg);
 void        append_move(Alg *alg, Move m, bool inverse);
 Move        base_move(Move m);
@@ -34,10 +35,71 @@ Alg *       on_inverse(Alg *alg);
 void        print_alg(Alg *alg, bool l);
 void        print_alglist(AlgList *al, bool l);
 void        swapmove(Move *m1, Move *m2);
+char *      trans_string(Trans t); /* Here because similar to move_string, move? */
 Alg *       unniss(Alg *alg);
 
 void        init_moveset(Moveset *ms);
-void        init_all_movesets();
+
+/* Movesets ******************************************************************/
+
+#ifndef ALG_C
+
+extern Moveset moveset_HTM;
+extern Moveset moveset_URF;
+extern Moveset moveset_eofb;
+extern Moveset moveset_drud;
+extern Moveset moveset_htr;
+
+extern Moveset * all_ms[];
+
+#else
+
+Moveset
+moveset_HTM = {
+	.name         = "HTM",
+	.allowed      = allowed_HTM,
+	.allowed_next = allowed_next_all,
+};
+
+Moveset
+moveset_URF = {
+	.name         = "URF",
+	.allowed      = allowed_URF,
+	.allowed_next = allowed_next_all,
+};
+
+Moveset
+moveset_eofb = {
+	.name         = "eofb",
+	.allowed      = allowed_eofb,
+	.allowed_next = allowed_next_all,
+};
+
+Moveset
+moveset_drud = {
+	.name         = "drud",
+	.allowed      = allowed_drud,
+	.allowed_next = allowed_next_all,
+};
+
+Moveset
+moveset_htr = {
+	.name         = "htr",
+	.allowed      = allowed_htr,
+	.allowed_next = allowed_next_all,
+};
+
+Moveset *
+all_ms[] = {
+	&moveset_HTM,
+	&moveset_URF,
+	&moveset_eofb,
+	&moveset_drud,
+	&moveset_htr,
+	NULL
+};
+
+#endif
 
 #endif
 
diff --git a/src/commands.c b/src/commands.c
@@ -1,187 +1,11 @@
-#include "commands.h"
+#define COMMANDS_C
 
-/* Arg parsing functions *****************************************************/
-
-CommandArgs *           gen_parse_args(int c, char **v);
-CommandArgs *           help_parse_args(int c, char **v);
-CommandArgs *           parse_only_scramble(int c, char **v);
-CommandArgs *           parse_no_arg(int c, char **v);
-CommandArgs *           solve_parse_args(int c, char **v);
-CommandArgs *           scramble_parse_args(int c, char **v);
-
-/* Exec functions ************************************************************/
-
-static void             gen_exec(CommandArgs *args);
-static void             cleanup_exec(CommandArgs *args);
-static void             invert_exec(CommandArgs *args);
-static void             solve_exec(CommandArgs *args);
-static void             scramble_exec(CommandArgs *args);
-static void             steps_exec(CommandArgs *args);
-static void             commands_exec(CommandArgs *args);
-static void             freemem_exec(CommandArgs *args);
-static void             print_exec(CommandArgs *args);
-static void             twophase_exec(CommandArgs *args);
-static void             help_exec(CommandArgs *args);
-static void             quit_exec(CommandArgs *args);
-static void             unniss_exec(CommandArgs *args);
-static void             version_exec(CommandArgs *args);
-
-/* Local functions ***********************************************************/
+#include "commands.h"
 
 static bool             read_step(CommandArgs *args, char *str);
 static bool             read_scrtype(CommandArgs *args, char *str);
 static bool             read_scramble(int c, char **v, CommandArgs *args);
 
-/* Commands ******************************************************************/
-
-Command
-solve_cmd = {
-	.name        = "solve",
-	.usage       = "solve STEP [OPTIONS] SCRAMBLE",
-	.description = "Solve a step; see command steps for a list of steps",
-	.parse_args  = solve_parse_args,
-	.exec        = solve_exec
-};
-
-Command
-scramble_cmd = {
-	.name        = "scramble",
-	.usage       = "scramble [TYPE] [-n N]",
-	.description = "Get a random-position scramble",
-	.parse_args  = scramble_parse_args,
-	.exec        = scramble_exec,
-};
-
-Command
-gen_cmd = {
-	.name        = "gen",
-	.usage       = "gen [-t N]",
-	.description = "Generate all tables [using N threads]",
-	.parse_args  = gen_parse_args,
-	.exec        = gen_exec
-};
-
-Command
-invert_cmd = {
-	.name        = "invert",
-	.usage       = "invert SCRAMBLE]",
-	.description = "Invert a scramble",
-	.parse_args  = parse_only_scramble,
-	.exec        = invert_exec,
-};
-
-Command
-steps_cmd = {
-	.name        = "steps",
-	.usage       = "steps",
-	.description = "List available steps",
-	.parse_args  = parse_no_arg,
-	.exec        = steps_exec
-};
-
-Command
-commands_cmd = {
-	.name        = "commands",
-	.usage       = "commands",
-	.description = "List available commands",
-	.parse_args  = parse_no_arg,
-	.exec        = commands_exec
-};
-
-Command
-freemem_cmd = {
-	.name        = "freemem",
-	.usage       = "freemem",
-	.description = "free large tables from RAM",
-	.parse_args  = parse_no_arg,
-	.exec        = freemem_exec,
-};
-
-Command
-print_cmd = {
-	.name        = "print",
-	.usage       = "print SCRAMBLE",
-	.description = "Print written description of the cube",
-	.parse_args  = parse_only_scramble,
-	.exec        = print_exec,
-};
-
-Command
-help_cmd = {
-	.name        = "help",
-	.usage       = "help [COMMAND]",
-	.description = "Display nissy manual page or help on specific command",
-	.parse_args  = help_parse_args,
-	.exec        = help_exec,
-};
-
-Command
-twophase_cmd = {
-	.name        = "twophase",
-	.usage       = "twophase",
-	.description = "Find a solution quickly using a 2-phase method",
-	.parse_args  = parse_only_scramble,
-	.exec        = twophase_exec,
-};
-
-Command
-quit_cmd = {
-	.name        = "quit",
-	.usage       = "quit",
-	.description = "Quit nissy",
-	.parse_args  = parse_no_arg,
-	.exec        = quit_exec,
-};
-
-Command
-cleanup_cmd = {
-	.name        = "cleanup",
-	.usage       = "cleanup SCRAMBLE",
-	.description = "Rewrite a scramble using only standard moves (HTM)",
-	.parse_args  = parse_only_scramble,
-	.exec        = cleanup_exec,
-};
-
-Command
-unniss_cmd = {
-	.name        = "unniss",
-	.usage       = "unniss SCRAMBLE",
-	.description = "Rewrite a scramble without NISS",
-	.parse_args  = parse_only_scramble,
-	.exec        = unniss_exec,
-};
-
-Command
-version_cmd = {
-	.name        = "version",
-	.usage       = "version",
-	.description = "print nissy version",
-	.parse_args  = parse_no_arg,
-	.exec        = version_exec,
-};
-
-Command *commands[] = {
-	&commands_cmd,
-	&freemem_cmd,
-	&gen_cmd,
-	&help_cmd,
-	&invert_cmd,
-	&print_cmd,
-	&quit_cmd,
-	&solve_cmd,
-	&scramble_cmd,
-	&steps_cmd,
-	&twophase_cmd,
-	&cleanup_cmd,
-	&unniss_cmd,
-	&version_cmd,
-	NULL
-};
-
-/* Other constants ***********************************************************/
-
-char *scrtypes[20] = { "eo", "corners", "edges", "fmc", "dr", "htr", NULL };
-
 /* Arg parsing functions implementation **************************************/
 
 CommandArgs *
@@ -386,17 +210,15 @@ parse_no_arg(int c, char **v)
 
 /* Exec functions implementation *********************************************/
 
-static void
+void
 solve_exec(CommandArgs *args)
 {
 	Cube c;
 	AlgList *sols;
 
-	init_all_movesets();
-	init_symcoord();
-
-	c = apply_alg(args->scramble, (Cube){0});
-	sols = solve(c, args->step, args->opts);
+	make_solved(&c);
+	apply_alg(args->scramble, &c);
+	sols = solve(&c, args->step, args->opts);
 
 	if (args->opts->count_only)
 		printf("%d\n", sols->len);
@@ -406,85 +228,64 @@ solve_exec(CommandArgs *args)
 	free_alglist(sols);
 }
 
-static void
+void
 scramble_exec(CommandArgs *args)
 {
 	Cube cube;
-	CubeArray *arr;
 	Alg *scr, *ruf, *aux;
-	int i, j, eo, ep, co, cp, a[12];
-	int eparr[12] = { [8] = 8, [9] = 9, [10] = 10, [11] = 11 };
+	int i, j, eo, ep, co, cp;
 	uint64_t ui, uj, uk;
 
-	init_all_movesets();
-	init_symcoord();
-
 	srand(time(NULL));
 
 	for (i = 0; i < args->n; i++) {
 
 		if (!strcmp(args->scrtype, "dr")) {
-			/* Warning: cube is inconsistent because of side CO  *
-			 * and EO on U/D. But solve_2phase only solves drfin *
-			 * in this case, so it should be ok.                 *
-			 * TODO: check this properly                         *
-			 * Moreover we again need to fix parity after        *
-			 * generating epose manually                         */
-			do {
-				ui = rand() % FACTORIAL8;
-				uj = rand() % FACTORIAL8;
-				uk = rand() % FACTORIAL4;
-
-				index_to_perm(ui, 12, a);
-				arr = malloc(sizeof(CubeArray));
-				arr->ep = eparr;
-				cube = arrays_to_cube(arr, pf_ep);
-				free(arr);
-
-				cube.cp = uj;
-				cube.epose += uk;
-			} while (!is_admissible(cube));
+			ui = rand() % FACTORIAL8;
+			uj = rand() % FACTORIAL8;
+			uk = rand() % FACTORIAL4;
+
+			make_solved(&cube);
+			index_to_perm(ui, 8, cube.cp);
+			index_to_perm(uj, 8, cube.ep);
+			index_to_perm(uk, 4, cube.ep + 8);
+			for (j = 8; j < 12; j++)
+				cube.ep[j] += 8;
 		} else if (!strcmp(args->scrtype, "htr")) {
-			/* antindex_htrfin() returns a consistent *
-			 * cube, except possibly for parity       */
-			do {
-				ui = rand() % (24*24/6);
-				cube = (Cube){0};
-				cube.cp = cornershtrfin_ant[ui];
-				cube.epose = rand() % 24;
-				cube.eposs = rand() % 24;
-				cube.eposm = rand() % 24;
-			} while (!is_admissible(cube));
+			make_solved(&cube);
+			/* TODO */
 		} else {
-			eo = rand() % POW2TO11;
 			ep = rand() % FACTORIAL12;
-			co = rand() % POW3TO7;
 			cp = rand() % FACTORIAL8;
+			eo = rand() % POW2TO11;
+			co = rand() % POW3TO7;
 
 			if (!strcmp(args->scrtype, "eo")) {
 				eo = 0;
 			} else if (!strcmp(args->scrtype, "corners")) {
 				eo = 0;
 				ep = 0;
-				index_to_perm(cp, 8, a);
-				if (perm_sign(a, 8) == 1) {
-					swap(&a[0], &a[1]);
-					cp = perm_to_index(a, 8);
-				}
 			} else if (!strcmp(args->scrtype, "edges")) {
 				co = 0;
 				cp = 0;
-				index_to_perm(ep, 12, a);
-				if (perm_sign(a, 12) == 1) {
-					swap(&a[0], &a[1]);
-					ep = perm_to_index(a, 12);
-				}
 			}
-			cube = fourval_to_cube(eo, ep, co, cp);
+
+			make_solved(&cube);
+			index_to_perm(ep, 12, cube.ep);
+			index_to_perm(cp,  8, cube.cp);
+			int_to_sum_zero_array(eo, 2, 12, cube.eo);
+			int_to_sum_zero_array(co, 3,  8, cube.co);
+		}
+
+		if (!is_admissible(&cube)) {
+			if (!strcmp(args->scrtype, "corners"))
+				swap(&cube.cp[UFR], &cube.cp[UFL]);
+			else
+				swap(&cube.ep[UF], &cube.ep[UB]);
 		}
 
 		/* TODO: can be optimized for htr and dr using htrfin, drfin */
-		scr = solve_2phase(cube, 1);
+		scr = solve_2phase(&cube, 1);
 
 		if (!strcmp(args->scrtype, "fmc")) {
 			aux = new_alg("");
@@ -513,23 +314,22 @@ scramble_exec(CommandArgs *args)
 	}
 }
 
-static void
+void
 gen_exec(CommandArgs *args)
 {
+/* TODO:
 	int i;
 
 	fprintf(stderr, "Generating coordinates...\n");
-	init_all_movesets();
-	init_symcoord();
-
 	fprintf(stderr, "Generating pruning tables...\n");
 	for (i = 0; all_pd[i] != NULL; i++)
 		genptable(all_pd[i], args->opts->nthreads);
+*/
 
 	fprintf(stderr, "Done!\n");
 }
 
-static void
+void
 invert_exec(CommandArgs *args)
 {
 	Alg *inv;
@@ -540,7 +340,7 @@ invert_exec(CommandArgs *args)
 	free_alg(inv);
 }
 
-static void
+void
 steps_exec(CommandArgs *args)
 {
 	int i;
@@ -549,7 +349,7 @@ steps_exec(CommandArgs *args)
 		printf("%-15s %s\n", steps[i]->shortname, steps[i]->name);
 }
 
-static void
+void
 commands_exec(CommandArgs *args)
 {
 	int i;
@@ -559,9 +359,10 @@ commands_exec(CommandArgs *args)
 
 }
 
-static void
+void
 freemem_exec(CommandArgs *args)
 {
+/* TODO:
 	int i;
 
 	for (i = 0; all_pd[i] != NULL; i++)
@@ -569,35 +370,34 @@ freemem_exec(CommandArgs *args)
 
 	for (i = 0; all_sd[i] != NULL; i++)
 		free_sd(all_sd[i]);
-
-	/* TODO: invtables are also large, but for now they are *
-	 * statically allocated. Consider releasing those too.  */
+*/
 }
 
-static void
+void
 print_exec(CommandArgs *args)
 {
-	init_moves();
-	print_cube(apply_alg(args->scramble, (Cube){0}));
+	Cube c;
+
+	make_solved(&c);
+	apply_alg(args->scramble, &c);
+	print_cube(&c);
 }
 
-static void
+void
 twophase_exec(CommandArgs *args)
 {
 	Cube c;
 	Alg *sol;
 
-	init_all_movesets();
-	init_symcoord();
-
-	c = apply_alg(args->scramble, (Cube){0});
-	sol = solve_2phase(c, 1);
+	make_solved(&c);
+	apply_alg(args->scramble, &c);
+	sol = solve_2phase(&c, 1);
 
 	print_alg(sol, false);
 	free_alg(sol);
 }
 
-static void
+void
 help_exec(CommandArgs *args)
 {
 	if (args->command == NULL) {
@@ -619,26 +419,24 @@ help_exec(CommandArgs *args)
 	}
 }
 
-static void
+void
 quit_exec(CommandArgs *args)
 {
 	exit(0);
 }
 
-static void
+void
 cleanup_exec(CommandArgs *args)
 {
 	Alg *alg;
 
-	init_moves();
-
 	alg = cleanup(args->scramble);
 	print_alg(alg, false);
 
 	free_alg(alg);
 }
 
-static void
+void
 unniss_exec(CommandArgs *args)
 {
 	Alg *aux;
@@ -648,7 +446,7 @@ unniss_exec(CommandArgs *args)
 	free(aux);
 }
 
-static void
+void
 version_exec(CommandArgs *args)
 {
 	printf(VERSION"\n");
@@ -691,6 +489,8 @@ static bool
 read_scrtype(CommandArgs *args, char *str)
 {
 	int i;
+	static char *scrtypes[20] =
+	    { "eo", "corners", "edges", "fmc", "dr", "htr", NULL };
 
 	for (i = 0; scrtypes[i] != NULL; i++) {
 		if (!strcmp(scrtypes[i], str)) {
diff --git a/src/commands.h b/src/commands.h
@@ -9,6 +9,198 @@
 void                    free_args(CommandArgs *args);
 CommandArgs *           new_args();
 
-extern Command *        commands[];
+/* Arg parsing functions *****************************************************/
+
+CommandArgs *           gen_parse_args(int c, char **v);
+CommandArgs *           help_parse_args(int c, char **v);
+CommandArgs *           parse_only_scramble(int c, char **v);
+CommandArgs *           parse_no_arg(int c, char **v);
+CommandArgs *           solve_parse_args(int c, char **v);
+CommandArgs *           scramble_parse_args(int c, char **v);
+
+/* Exec functions ************************************************************/
+
+void                    gen_exec(CommandArgs *args);
+void                    cleanup_exec(CommandArgs *args);
+void                    invert_exec(CommandArgs *args);
+void                    solve_exec(CommandArgs *args);
+void                    scramble_exec(CommandArgs *args);
+void                    steps_exec(CommandArgs *args);
+void                    commands_exec(CommandArgs *args);
+void                    freemem_exec(CommandArgs *args);
+void                    print_exec(CommandArgs *args);
+void                    twophase_exec(CommandArgs *args);
+void                    help_exec(CommandArgs *args);
+void                    quit_exec(CommandArgs *args);
+void                    unniss_exec(CommandArgs *args);
+void                    version_exec(CommandArgs *args);
+
+/* Commands ******************************************************************/
+
+#ifndef COMMANDS_C
+
+extern Command cleanup_cmd;
+extern Command commands_cmd;
+extern Command freemem_cmd;
+extern Command gen_cmd;
+extern Command help_cmd;
+extern Command invert_cmd;
+extern Command print_cmd;
+extern Command quit_cmd;
+extern Command scramble_cmd;
+extern Command solve_cmd;
+extern Command steps_cmd;
+extern Command unniss_cmd;
+extern Command version_cmd;
+
+extern Command *commands[];
+
+#else
+
+Command
+solve_cmd = {
+	.name        = "solve",
+	.usage       = "solve STEP [OPTIONS] SCRAMBLE",
+	.description = "Solve a step; see command steps for a list of steps",
+	.parse_args  = solve_parse_args,
+	.exec        = solve_exec
+};
+
+Command
+scramble_cmd = {
+	.name        = "scramble",
+	.usage       = "scramble [TYPE] [-n N]",
+	.description = "Get a random-position scramble",
+	.parse_args  = scramble_parse_args,
+	.exec        = scramble_exec,
+};
+
+Command
+gen_cmd = {
+	.name        = "gen",
+	.usage       = "gen [-t N]",
+	.description = "Generate all tables [using N threads]",
+	.parse_args  = gen_parse_args,
+	.exec        = gen_exec
+};
+
+Command
+invert_cmd = {
+	.name        = "invert",
+	.usage       = "invert SCRAMBLE]",
+	.description = "Invert a scramble",
+	.parse_args  = parse_only_scramble,
+	.exec        = invert_exec,
+};
+
+Command
+steps_cmd = {
+	.name        = "steps",
+	.usage       = "steps",
+	.description = "List available steps",
+	.parse_args  = parse_no_arg,
+	.exec        = steps_exec
+};
+
+Command
+commands_cmd = {
+	.name        = "commands",
+	.usage       = "commands",
+	.description = "List available commands",
+	.parse_args  = parse_no_arg,
+	.exec        = commands_exec
+};
+
+Command
+freemem_cmd = {
+	.name        = "freemem",
+	.usage       = "freemem",
+	.description = "free large tables from RAM",
+	.parse_args  = parse_no_arg,
+	.exec        = freemem_exec,
+};
+
+Command
+print_cmd = {
+	.name        = "print",
+	.usage       = "print SCRAMBLE",
+	.description = "Print written description of the cube",
+	.parse_args  = parse_only_scramble,
+	.exec        = print_exec,
+};
+
+Command
+help_cmd = {
+	.name        = "help",
+	.usage       = "help [COMMAND]",
+	.description = "Display nissy manual page or help on specific command",
+	.parse_args  = help_parse_args,
+	.exec        = help_exec,
+};
+
+Command
+twophase_cmd = {
+	.name        = "twophase",
+	.usage       = "twophase",
+	.description = "Find a solution quickly using a 2-phase method",
+	.parse_args  = parse_only_scramble,
+	.exec        = twophase_exec,
+};
+
+Command
+quit_cmd = {
+	.name        = "quit",
+	.usage       = "quit",
+	.description = "Quit nissy",
+	.parse_args  = parse_no_arg,
+	.exec        = quit_exec,
+};
+
+Command
+cleanup_cmd = {
+	.name        = "cleanup",
+	.usage       = "cleanup SCRAMBLE",
+	.description = "Rewrite a scramble using only standard moves (HTM)",
+	.parse_args  = parse_only_scramble,
+	.exec        = cleanup_exec,
+};
+
+Command
+unniss_cmd = {
+	.name        = "unniss",
+	.usage       = "unniss SCRAMBLE",
+	.description = "Rewrite a scramble without NISS",
+	.parse_args  = parse_only_scramble,
+	.exec        = unniss_exec,
+};
+
+Command
+version_cmd = {
+	.name        = "version",
+	.usage       = "version",
+	.description = "print nissy version",
+	.parse_args  = parse_no_arg,
+	.exec        = version_exec,
+};
+
+Command *commands[] = {
+	&commands_cmd,
+	&freemem_cmd,
+	&gen_cmd,
+	&help_cmd,
+	&invert_cmd,
+	&print_cmd,
+	&quit_cmd,
+	&solve_cmd,
+	&scramble_cmd,
+	&steps_cmd,
+	&twophase_cmd,
+	&cleanup_cmd,
+	&unniss_cmd,
+	&version_cmd,
+	NULL
+};
+
+#endif
 
 #endif
diff --git a/src/coord.c b/src/coord.c
@@ -1,611 +1,683 @@
+#define COORD_C
+
 #include "coord.h"
 
-static uint64_t    index_eofb(Cube cube);
-static uint64_t    index_eofbepos(Cube cube);
-static uint64_t    index_epud(Cube cube);
-static uint64_t    index_coud(Cube cube);
-static uint64_t    index_corners(Cube cube);
-static uint64_t    index_cp(Cube cube);
-static uint64_t    index_cphtr(Cube cube);
-static uint64_t    index_cornershtr(Cube cube);
-static uint64_t    index_cornershtrfin(Cube cube);
-static uint64_t    index_drud(Cube cube);
-static uint64_t    index_drud_eofb(Cube cube);
-static uint64_t    index_htr_drud(Cube cube);
-static uint64_t    index_htrfin(Cube cube);
-static uint64_t    index_cpud_separate(Cube cube);
-
-static uint64_t    move_eofb(Move m, uint64_t ind);
-static uint64_t    move_eofbepos(Move m, uint64_t ind);
-static uint64_t    move_epud(Move m, uint64_t ind);
-static uint64_t    move_coud(Move m, uint64_t ind);
-static uint64_t    move_corners(Move m, uint64_t ind);
-static uint64_t    move_cp(Move m, uint64_t ind);
-static uint64_t    move_cphtr(Move m, uint64_t ind);
-static uint64_t    move_cornershtr(Move m, uint64_t ind);
-static uint64_t    move_cornershtrfin(Move m, uint64_t ind);
-static uint64_t    move_drud(Move m, uint64_t ind);
-static uint64_t    move_drud_eofb(Move m, uint64_t ind);
-static uint64_t    move_htr_drud(Move m, uint64_t ind);
-static uint64_t    move_htrfin(Move m, uint64_t ind);
-static uint64_t    move_cpud_separate(Move m, uint64_t ind);
-
-static void        init_cphtr_cosets();
-static void        init_cphtr_left_cosets_bfs(int i, int c);
-static void        init_cphtr_right_cosets_color(int i, int c);
-static void        init_cpud_separate();
-static void        init_cornershtrfin();
-static void        init_htr_eposs();
-
-
-/* All sorts of useful costants and tables  **********************************/
-
-static int              cphtr_left_cosets[FACTORIAL8];
-static int              cphtr_right_cosets[FACTORIAL8];
-static int              cphtr_right_rep[BINOM8ON4*6];
-int                     cpud_separate_ind[FACTORIAL8];
-int                     cpud_separate_ant[BINOM8ON4];
-static int              cornershtrfin_ind[FACTORIAL8];
-int                     cornershtrfin_ant[24*24/6];
-static int              htr_eposs_ind[BINOM12ON4];
-static int              htr_eposs_ant[BINOM8ON4];
-
-/* Coordinates and their implementation **************************************/
-
-Coordinate
-coord_eofb = {
-	.index  = index_eofb,
-	.max    = POW2TO11,
-	.move   = move_eofb,
-};
-
-Coordinate
-coord_eofbepos = {
-	.index  = index_eofbepos,
-	.max    = POW2TO11 * BINOM12ON4,
-	.move   = move_eofbepos,
-};
-
-Coordinate
-coord_coud = {
-	.index  = index_coud,
-	.max    = POW3TO7,
-	.move   = move_coud,
-};
-
-Coordinate
-coord_corners = {
-	.index  = index_corners,
-	.max    = POW3TO7 * FACTORIAL8,
-	.move   = move_corners,
-};
-
-Coordinate
-coord_cp = {
-	.index  = index_cp,
-	.max    = FACTORIAL8,
-	.move   = move_cp,
-};
-
-Coordinate
-coord_cphtr = {
-	.index  = index_cphtr,
-	.max    = BINOM8ON4 * 6,
-	.move   = move_cphtr,
-};
-
-Coordinate
-coord_cornershtr = {
-	.index  = index_cornershtr,
-	.max    = POW3TO7 * BINOM8ON4 * 6,
-	.move   = move_cornershtr,
-};
-
-Coordinate
-coord_cornershtrfin = {
-	.index  = index_cornershtrfin,
-	.max    = 24*24/6,
-	.move   = move_cornershtrfin,
-};
-
-Coordinate
-coord_epud = {
-	.index  = index_epud,
-	.max    = FACTORIAL8,
-	.move   = move_epud,
-};
-
-Coordinate
-coord_drud = {
-	.index  = index_drud,
-	.max    = POW2TO11 * POW3TO7 * BINOM12ON4,
-	.move   = move_drud,
-};
-
-Coordinate
-coord_htr_drud = {
-	.index  = index_htr_drud,
-	.max    = BINOM8ON4 * 6 * BINOM8ON4,
-	.move   = move_htr_drud,
-};
-
-Coordinate
-coord_htrfin = {
-	.index  = index_htrfin,
-	.max    = 24 * 24 * 24 *24 * 24 / 6, /* should be /12 but it's ok */
-	.move   = move_htrfin,
-};
-
-Coordinate
-coord_drud_eofb = {
-	.index  = index_drud_eofb,
-	.max    = POW3TO7 * BINOM12ON4,
-	.move   = move_drud_eofb,
-};
-
-Coordinate
-coord_cpud_separate = {
-	.index  = index_cpud_separate,
-	.max    = BINOM8ON4,
-	.move   = move_cpud_separate,
-};
+static uint64_t    indexers_getind(Indexer **is, Cube *c);
+static uint64_t    indexers_getmax(Indexer **is);
+static void        indexers_makecube(Indexer **is, uint64_t ind, Cube *c);
+static void        gen_coord_comp(Coordinate *coord);
+static void        gen_coord_sym(Coordinate *coord);
+static bool        read_coord_mtable(Coordinate *coord);
+static bool        read_coord_sd(Coordinate *coord);
+static bool        read_coord_ttable(Coordinate *coord);
+static bool        write_coord_mtable(Coordinate *coord);
+static bool        write_coord_sd(Coordinate *coord);
+static bool        write_coord_ttable(Coordinate *coord);
 
 /* Indexers ******************************************************************/
 
-static uint64_t
-index_eofb(Cube cube)
+uint64_t
+index_eofb(Cube *cube)
 {
-	return cube.eofb;
+	return (uint64_t)digit_array_to_int(cube->eo, 11, 2);
 }
 
-static uint64_t
-index_eofbepos(Cube cube)
+uint64_t
+index_coud(Cube *cube)
 {
-	return (cube.epose / FACTORIAL4) * POW2TO11 + cube.eofb;
+	return (uint64_t)digit_array_to_int(cube->co, 7, 3);
 }
 
-static uint64_t
-index_epud(Cube cube)
+uint64_t
+index_cp(Cube *cube)
+{
+	return (uint64_t)perm_to_index(cube->cp, 8);
+}
+
+uint64_t
+index_cpudsep(Cube *cube)
 {
-	uint64_t ret;
-	CubeArray *arr = new_cubearray(cube, pf_ep);
+	int i, c[8];
 
-	ret = perm_to_index(arr->ep, 8);
-	free_cubearray(arr, pf_ep);
+	for (i = 0; i < 8; i++)
+		c[i] = cube->cp[i] < 4 ? 0 : 1;
 
-	return ret;
+	return (uint64_t)subset_to_index(c, 8, 4);
 }
 
-static uint64_t
-index_coud(Cube cube)
+uint64_t
+index_epe(Cube *cube)
 {
-	return cube.coud;
+	int i, e[4];
+
+	for (i = 0; i < 4; i++)
+		e[i] = cube->ep[i+8] - 8;
+
+	return (uint64_t)perm_to_index(e, 4);
 }
 
-static uint64_t
-index_corners(Cube cube)
+uint64_t
+index_epud(Cube *cube)
 {
-	return cube.coud * FACTORIAL8 + cube.cp;
+	return (uint64_t)perm_to_index(cube->ep, 8);
 }
 
-static uint64_t
-index_cp(Cube cube)
+uint64_t
+index_epos(Cube *cube)
 {
-	return cube.cp;
+	int i, a[12];
+
+	for (i = 0; i < 12; i++)
+		a[i] = (cube->ep[i] < 8) ? 0 : 1;
+
+	return (uint64_t)subset_to_index(a, 12, 4);
 }
 
-static uint64_t
-index_cphtr(Cube cube)
+uint64_t
+index_eposepe(Cube *cube)
 {
-	return cphtr_right_cosets[cube.cp];
+	int i, j, e[4];
+	uint64_t epos, epe;
+
+	epos = (uint64_t)index_epos(cube);
+	for (i = 0, j = 0; i < 12; i++)
+		if (cube->ep[i] >= 8)
+			e[j++] = cube->ep[i] - 8;
+	epe = (uint64_t)perm_to_index(e, 4);
+
+	return epos * FACTORIAL4 + epe;
 }
 
-static uint64_t
-index_cornershtr(Cube cube)
+/* Inverse indexers **********************************************************/
+
+void
+invindex_eofb(uint64_t ind, Cube *cube)
 {
-	return cube.coud * BINOM8ON4 * 6 + index_cphtr(cube);
+	int_to_sum_zero_array(ind, 2, 12, cube->eo);
 }
 
-static uint64_t
-index_cornershtrfin(Cube cube)
+void
+invindex_coud(uint64_t ind, Cube *cube)
 {
-	return cornershtrfin_ind[cube.cp];
+	int_to_sum_zero_array(ind, 3, 8, cube->co);
 }
 
-static uint64_t
-index_drud(Cube cube)
+void
+invindex_cp(uint64_t ind, Cube *cube)
 {
-	uint64_t a, b, c;
-
-	a = cube.eofb;
-	b = cube.coud;
-	c = cube.epose / FACTORIAL4;
+	index_to_perm(ind, 8, cube->cp);
+}
 
-	b *= POW2TO11;
-	c *= POW2TO11 * POW3TO7;
+void
+invindex_cpudsep(uint64_t ind, Cube *cube)
+{
+	int i, j, k, c[8];
 
-	return a + b + c;
+	index_to_subset(ind, 8, 4, c);
+	for (i = 0, j = 0, k = 4; i < 8; i++)
+		cube->cp[i] = c[i] == 0 ? j++ : k++;
 }
 
-static uint64_t
-index_drud_eofb(Cube cube)
+
+void
+invindex_epe(uint64_t ind, Cube *cube)
 {
-	return index_drud(cube) / POW2TO11;
+	int i;
+
+	index_to_perm(ind, 4, &cube->ep[8]);
+	for (i = 0; i < 4; i++)
+		cube->ep[i+8] += 8;
 }
 
-static uint64_t
-index_htr_drud(Cube cube)
+void
+invindex_epud(uint64_t ind, Cube *cube)
 {
-	uint64_t a, b;
+	index_to_perm(ind, 8, cube->ep);
+}
 
-	a = index_cphtr(cube);
-	b = htr_eposs_ind[cube.eposs/24];
+void
+invindex_epos(uint64_t ind, Cube *cube)
+{
+	int i, j, k;
 
-	return a * BINOM8ON4 + b;
+	index_to_subset(ind, 12, 4, cube->ep);
+	for (i = 0, j = 0, k = 8; i < 12; i++)
+		if (cube->ep[i] == 0)
+			cube->ep[i] = j++;
+		else
+			cube->ep[i] = k++;
 }
 
-static uint64_t
-index_htrfin(Cube cube)
+void
+invindex_eposepe(uint64_t ind, Cube *cube)
 {
-	uint64_t epe, eps, epm, cp, ep;
+	int i, j, k, e[4];
+	uint64_t epos, epe;
+
+	epos = ind / FACTORIAL4;
+	epe = ind % FACTORIAL4;
 
-	epe = cube.epose % 24;
-	eps = cube.eposs % 24;
-	epm = cube.eposm % 24;
-	ep = (epe * 24 + eps) *24 + epm;
-	cp = index_cornershtrfin(cube);
+	index_to_subset(epos, 12, 4, cube->ep);
+	index_to_perm(epe, 4, e);
 
-	return cp * 24 * 24 * 24 + ep;
+	for (i = 0, j = 0, k = 0; i < 12; i++)
+		if (cube->ep[i] == 0)
+			cube->ep[i] = j++;
+		else
+			cube->ep[i] = e[k++] + 8;
 }
 
+/* Other local functions *****************************************************/
+
 static uint64_t
-index_cpud_separate(Cube cube)
+indexers_getmax(Indexer **is)
 {
-	return cpud_separate_ind[cube.cp];
-}
+	int i;
+	uint64_t max = 1;
 
-/* Coordinate movers *********************************************************/
+	for (i = 0; is[i] != NULL; i++)
+		max *= is[i]->n;
+
+	return max;
+}
 
 static uint64_t
-move_eofb(Move m, uint64_t ind)
+indexers_getind(Indexer **is, Cube *c)
 {
-	return eofb_mtable[m][ind];
+	int i;
+	uint64_t max = 0;
+
+	for (i = 0; is[i] != NULL; i++) {
+		max *= is[i]->n;
+		max += is[i]->index(c);
+	}
+
+	return max;
 }
 
-static uint64_t
-move_eofbepos(Move m, uint64_t ind)
+static void
+indexers_makecube(Indexer **is, uint64_t ind, Cube *c)
 {
-	uint64_t a, b;
+	/* Warning: anti-indexers are applied in the same order as indexers. */
+	/* We assume order does not matter, but it would make more sense to  */
+	/* Apply them in reverse.                                            */
 
-	a = epose_mtable[m][(ind / POW2TO11)*24];
-	b = eofb_mtable[m][ind % POW2TO11];
+	int i;
+	uint64_t m;
 
-	return (a/24) * POW2TO11 + b;
+	make_solved(c);
+	m = indexers_getmax(is);
+	for (i = 0; is[i] != NULL; i++) {
+		m /= is[i]->n;
+		is[i]->to_cube(ind / m, c);
+		ind %= m;
+	}
 }
 
-static uint64_t
-move_epud(Move m, uint64_t ind)
-{
-	/* TODO: save to file? */
-	static bool initialized = false;
-	static int a[12] = { [8] = 8, [9] = 9, [10] = 10, [11] = 11 };
-	static int shortlist[NMOVES] = {
-		[U] = 0, [U2] = 1, [U3] = 2, [D] = 3, [D2] = 4, [D3] = 5,
-		[R2] = 6, [L2] = 7, [F2] = 8, [B2] = 9
-	};
-	static uint64_t aux[10][FACTORIAL8];
+static void
+gen_coord_comp(Coordinate *coord)
+{
 	uint64_t ui;
-	int j;
-	Move mj;
-	Cube c;
-	CubeArray *arr, *auxarr;
+	Cube c, mvd;
+	Move m;
+	Trans t;
 
-	if (!moveset_drud.allowed(m)) {
-		fprintf(stderr, "Move not allowed for epud\n"
-		                "This is a bug, please report\n");
-		return coord_epud.max;
-	}
+	coord->max = indexers_getmax(coord->i);
+
+	for (m = 0; m < NMOVES; m++)
+		coord->mtable[m] = malloc(coord->max * sizeof(uint64_t));
+
+	for (t = 0; t < NTRANS; t++)
+		coord->ttable[t] = malloc(coord->max * sizeof(uint64_t));
+
+	if (!read_coord_mtable(coord)) {
+		fprintf(stderr, "%s: generating mtable\n", coord->name);
 
-	if (!initialized) {
-		auxarr = malloc(sizeof(CubeArray));
-		auxarr->ep = a;
-		for (ui = 0; ui < coord_epud.max; ui++) {
-			index_to_perm(ui, 8, a);
-			c = arrays_to_cube(auxarr, pf_ep);
-			for (j = 0; moveset_drud.sorted_moves[j] != NULLMOVE;
-			    j++) {
-				mj = moveset_drud.sorted_moves[j];
-				arr = new_cubearray(apply_move(mj, c), pf_ep);
-				aux[shortlist[mj]][ui] =
-				    perm_to_index(arr->ep, 8);
-				free_cubearray(arr, pf_ep);
+		for (ui = 0; ui < coord->max; ui++) {
+			indexers_makecube(coord->i, ui, &c);
+			for (m = 0; m < NMOVES; m++) {
+				copy_cube(&c, &mvd);
+				apply_move(m, &mvd);
+				coord->mtable[m][ui] =
+				    indexers_getind(coord->i, &mvd);
 			}
 		}
-		free(auxarr);
-
-		initialized = true;
+		if (!write_coord_mtable(coord))
+			fprintf(stderr, "%s: error writing mtable\n",
+			    coord->name);
+		
+		fprintf(stderr, "%s: mtable generated\n", coord->name);
 	}
 
-	return aux[shortlist[m]][ind];
-}
+	if (!read_coord_ttable(coord)) {
+		fprintf(stderr, "%s: generating ttable\n", coord->name);
 
-static uint64_t
-move_coud(Move m, uint64_t ind)
-{
-	return coud_mtable[m][ind];
+		for (ui = 0; ui < coord->max; ui++) {
+			indexers_makecube(coord->i, ui, &c);
+			for (t = 0; t < NTRANS; t++) {
+				copy_cube(&c, &mvd);
+				apply_trans(t, &mvd);
+				coord->ttable[t][ui] =
+				    indexers_getind(coord->i, &mvd);
+			}
+		}
+		if (!write_coord_ttable(coord))
+			fprintf(stderr, "%s: error writing ttable\n",
+			    coord->name);
+	}
 }
 
-static uint64_t
-move_corners(Move m, uint64_t ind)
+static void
+gen_coord_sym(Coordinate *coord)
 {
-	uint64_t a, b;
+	uint64_t i, in, ui, uj, uu, M, nr;
+	int j;
+	Move m;
+	Trans t;
 
-	a = coud_mtable[m][ind / FACTORIAL8];
-	b = cp_mtable[m][ind % FACTORIAL8];
+	M = coord->base[0]->max;
+	coord->selfsim    = malloc(M * sizeof(uint64_t));
+	coord->symclass   = malloc(M * sizeof(uint64_t));
+	coord->symrep     = malloc(M * sizeof(uint64_t));
+	coord->transtorep = malloc(M * sizeof(Trans));
 
-	return a * FACTORIAL8 + b;
-}
+	if (!read_coord_sd(coord)) {
+		fprintf(stderr, "%s: generating syms\n", coord->name);
 
-static uint64_t
-move_cp(Move m, uint64_t ind)
-{
-	return cp_mtable[m][ind];
-}
+		for (i = 0; i < M; i++)
+			coord->symclass[i] = M+1;
 
-static uint64_t
-move_cphtr(Move m, uint64_t ind)
-{
-	static bool initialized = false;
-	static uint64_t aux[NMOVES][BINOM8ON4*6];
-	uint64_t ui;
-	Move j;
+		for (i = 0, nr = 0; i < M; i++) {
+			if (coord->symclass[i] != M+1)
+				continue;
 
-	if (!initialized) {
-		for (ui = 0; ui < BINOM8ON4*6; ui++)
-			for (j = U; j < NMOVES; j++)
-				aux[j][ui] = cphtr_right_cosets[
-				    cp_mtable[j][cphtr_right_rep[ui]]];
+			coord->symrep[nr]    = i;
+			coord->transtorep[i] = uf;
+			coord->selfsim[nr]   = (uint64_t)0;
+			for (j = 0; j < coord->tgrp->n; j++) {
+				t = coord->tgrp->t[j];
+				in = trans_coord(coord->base[0], t, i);
+				coord->symclass[in] = nr;
+				if (in == i)
+					coord->selfsim[nr] |= ((uint64_t)1<<t);
+				else
+					coord->transtorep[in] =
+					    inverse_trans(t);
+			}
+			nr++;
+		}
 
-		initialized = true;
+		coord->max = nr;
+
+		fprintf(stderr, "%s: found %" PRIu64 " classes\n",
+		    coord->name, nr);
+		if (!write_coord_sd(coord))
+			fprintf(stderr, "%s: error writing symdata\n",
+			    coord->name);
 	}
 
-	return aux[m][ind];
+	coord->symrep = realloc(coord->symrep, coord->max*sizeof(uint64_t));
+	coord->selfsim = realloc(coord->selfsim, coord->max*sizeof(uint64_t));
+
+	for (m = 0; m < NMOVES; m++) {
+		coord->mtable[m] = malloc(coord->max*sizeof(uint64_t));
+		coord->ttrep_move[m] = malloc(coord->max*sizeof(Trans));
+	}
+
+	if (!read_coord_mtable(coord)) {
+		for (ui = 0; ui < coord->max; ui++) {
+			uu = coord->symrep[ui];
+			for (m = 0; m < NMOVES; m++) {
+				uj = move_coord(coord->base[0], m, uu, NULL);
+				coord->mtable[m][ui] = coord->symclass[uj];
+				coord->ttrep_move[m][ui] =
+				    coord->transtorep[uj];
+			}
+		}
+		if (!write_coord_mtable(coord))
+			fprintf(stderr, "%s: error writing mtable\n",
+			    coord->name);
+	}
 }
 
-static uint64_t
-move_cornershtr(Move m, uint64_t ind)
+static bool
+read_coord_mtable(Coordinate *coord)
 {
-	uint64_t a, b;
+	FILE *f;
+	char fname[strlen(tabledir)+256];
+	Move m;
+	uint64_t M;
+	bool r;
+
+	strcpy(fname, tabledir);
+	strcat(fname, "/mt_");
+	strcat(fname, coord->name);
+
+	if ((f = fopen(fname, "rb")) == NULL)
+		return false;
 
-	a = coud_mtable[m][ind/(BINOM8ON4 * 6)];
-	b = move_cphtr(m, ind % (BINOM8ON4 * 6));
+	M = coord->max;
+	r = true;
+	for (m = 0; m < NMOVES; m++)
+		r = r && fread(coord->mtable[m], sizeof(uint64_t), M, f) == M;
 
-	return a * BINOM8ON4 * 6 + b;
+	if (coord->type == SYM_COORD)
+		for (m = 0; m < NMOVES; m++)
+			r = r && fread(coord->ttrep_move[m],
+			    sizeof(Trans), M, f) == M;
+
+	fclose(f);
+	return r;
 }
 
-static uint64_t
-move_cornershtrfin(Move m, uint64_t ind)
+static bool
+read_coord_sd(Coordinate *coord)
 {
-	int a;
+	FILE *f;
+	char fname[strlen(tabledir)+256];
+	uint64_t M, N;
+	bool r;
+
+	strcpy(fname, tabledir);
+	strcat(fname, "/sd_");
+	strcat(fname, coord->name);
 
-	a = cp_mtable[m][cornershtrfin_ant[ind]];
+	if ((f = fopen(fname, "rb")) == NULL)
+		return false;
 
-	return cornershtrfin_ind[a];
+	r = true;
+	r = r && fread(&coord->max,       sizeof(uint64_t), 1, f) == 1;
+	M = coord->max;
+	N = coord->base[0]->max;
+	r = r && fread(coord->symrep,     sizeof(uint64_t), M, f) == M;
+	r = r && fread(coord->selfsim,    sizeof(uint64_t), M, f) == M;
+	r = r && fread(coord->symclass,   sizeof(uint64_t), N, f) == N;
+	r = r && fread(coord->transtorep, sizeof(Trans),    N, f) == N;
+
+	fclose(f);
+	return r;
 }
 
-static uint64_t
-move_drud(Move m, uint64_t ind)
+static bool
+read_coord_ttable(Coordinate *coord)
 {
-	uint64_t a, b, c;
+	FILE *f;
+	char fname[strlen(tabledir)+256];
+	Trans t;
+	uint64_t M;
+	bool r;
 
-	a = eofb_mtable[m][ind % POW2TO11];
-	b = coud_mtable[m][(ind / POW2TO11) % POW3TO7];
-	c = epose_mtable[m][ind / (POW2TO11 * POW3TO7)];
+	strcpy(fname, tabledir);
+	strcat(fname, "/tt_");
+	strcat(fname, coord->name);
 
-	return a + (b + c * POW3TO7) * POW2TO11;
+	if ((f = fopen(fname, "rb")) == NULL)
+		return false;
+
+	M = coord->max;
+	r = true;
+	for (t = 0; t < NTRANS; t++)
+		r = r && fread(coord->ttable[t], sizeof(uint64_t), M, f) == M;
+
+	fclose(f);
+	return r;
 }
 
-static uint64_t
-move_drud_eofb(Move m, uint64_t ind)
+static bool
+write_coord_mtable(Coordinate *coord)
 {
-	uint64_t a, b;
+	FILE *f;
+	char fname[strlen(tabledir)+256];
+	Move m;
+	uint64_t M;
+	bool r;
 
-	a = coud_mtable[m][ind % POW3TO7];
-	b = epose_mtable[m][(ind / POW3TO7) * 24] / 24;
+	strcpy(fname, tabledir);
+	strcat(fname, "/mt_");
+	strcat(fname, coord->name);
 
-	return a + b * POW3TO7;
+	if ((f = fopen(fname, "wb")) == NULL)
+		return false;
+
+	M = coord->max;
+	r = true;
+	for (m = 0; m < NMOVES; m++)
+		r = r && fwrite(coord->mtable[m], sizeof(uint64_t), M, f) == M;
+
+	if (coord->type == SYM_COORD)
+		for (m = 0; m < NMOVES; m++)
+			r = r && fwrite(coord->ttrep_move[m],
+			    sizeof(Trans), M, f) == M;
+
+	fclose(f);
+	return r;
 }
 
-static uint64_t
-move_htr_drud(Move m, uint64_t ind)
+static bool
+write_coord_sd(Coordinate *coord)
 {
-	uint64_t a, b;
+	FILE *f;
+	char fname[strlen(tabledir)+256];
+	uint64_t M, N;
+	bool r;
+
+	strcpy(fname, tabledir);
+	strcat(fname, "/sd_");
+	strcat(fname, coord->name);
 
-	a = move_cphtr(m, ind/BINOM8ON4);
-	b = eposs_mtable[m][htr_eposs_ant[ind%BINOM8ON4]];
+	if ((f = fopen(fname, "wb")) == NULL)
+		return false;
 
-	return a*BINOM8ON4 + htr_eposs_ind[b/24];
+	r = true;
+	M = coord->max;
+	N = coord->base[0]->max;
+	r = r && fwrite(&coord->max,       sizeof(uint64_t), 1, f) == 1;
+	r = r && fwrite(coord->symrep,     sizeof(uint64_t), M, f) == M;
+	r = r && fwrite(coord->selfsim,    sizeof(uint64_t), M, f) == M;
+	r = r && fwrite(coord->symclass,   sizeof(uint64_t), N, f) == N;
+	r = r && fwrite(coord->transtorep, sizeof(Trans),    N, f) == N;
+
+	fclose(f);
+	return r;
 }
 
-static uint64_t
-move_htrfin(Move m, uint64_t ind)
+static bool
+write_coord_ttable(Coordinate *coord)
 {
-	uint64_t a, b, bm, bs, be;
+	FILE *f;
+	char fname[strlen(tabledir)+256];
+	Trans t;
+	uint64_t M;
+	bool r;
+
+	strcpy(fname, tabledir);
+	strcat(fname, "/tt_");
+	strcat(fname, coord->name);
+
+	if ((f = fopen(fname, "wb")) == NULL)
+		return false;
 
-	a = move_cornershtrfin(m, ind / (24*24*24));
-	bm = eposm_mtable[m][ind%24] % 24;
-	bs = eposs_mtable[m][(ind/24)%24] % 24;
-	be = epose_mtable[m][(ind/(24*24))%24] % 24;
-	b = (be * 24 + bs) * 24 + bm;
+	M = coord->max;
+	r = true;
+	for (t = 0; t < NTRANS; t++)
+		r = r && fwrite(coord->ttable[t], sizeof(uint64_t), M, f) == M;
 
-	return a * (24*24*24) + b;
+	fclose(f);
+	return r;
 }
 
-static uint64_t
-move_cpud_separate(Move m, uint64_t ind)
-{
-	return cpud_separate_ind[cp_mtable[m][cpud_separate_ant[ind]]];
-}
-
-/* Init functions implementation *********************************************/
-
-/*
- * There is certainly a better way to do this, but for now I just use
- * a "graph coloring" algorithm to compute the left cosets, and I compose
- * with every possible cp to get the right cosets (it is possible that I am
- * mixing up left and right).
- * 
- * For doing it better "Mathematically", we need 3 things:
- *   - Checking that cp separates the orbits (UFR,UBL,DFL,DBR) and the other
- *     This is easy and it is done in the commented function cphtr_cp().
- *   - Check that there is no ep/cp parity
- *   - Check that we are not in the "3c" case; this is the part I don't
- *     know how to do.
- */
-static void
-init_cphtr_cosets()
+/* Public functions **********************************************************/
+
+void
+gen_coord(Coordinate *coord)
 {
-	unsigned int i; 
-	int c = 0, d = 0;
+	int i;
 
-	for (i = 0; i < FACTORIAL8; i++) {
-		cphtr_left_cosets[i]  = -1;
-		cphtr_right_cosets[i] = -1;
+	if (coord == NULL || coord->generated)
+		return;
+
+	for (i = 0; i < 2; i++)
+		gen_coord(coord->base[i]);
+
+	switch (coord->type) {
+	case COMP_COORD:
+		if (coord->i[0] == NULL)
+			goto error_gc;
+		gen_coord_comp(coord);
+		break;
+	case SYM_COORD:
+		if (coord->base[0] == NULL || coord->tgrp == NULL)
+			goto error_gc;
+		gen_coord_sym(coord);
+		break;
+	case SYMCOMP_COORD:
+		if (coord->base[0] == NULL || coord->base[1] == NULL)
+			goto error_gc;
+		coord->max = coord->base[0]->max * coord->base[1]->max;
+		break;
+	default:
+		break;
 	}
 
-	/* First we compute left cosets with a bfs */
-	for (i = 0; i < FACTORIAL8; i++)
-		if (cphtr_left_cosets[i] == -1)
-			init_cphtr_left_cosets_bfs(i, c++);
+	coord->generated = true;
+	return;
 
-	/* Then we compute right cosets using compose() */
-	for (i = 0; i < FACTORIAL8; i++)
-		if (cphtr_right_cosets[i] == -1)
-			init_cphtr_right_cosets_color(i, d++);
+error_gc:
+	fprintf(stderr, "Error generating coordinates.\n"
+			"This is a bug, pleae report.\n");
+	exit(1);
 }
 
-static void
-init_cphtr_left_cosets_bfs(int i, int c)
+uint64_t
+index_coord(Coordinate *coord, Cube *cube, Trans *offtrans)
 {
-	int j, jj, next[FACTORIAL8], next2[FACTORIAL8], n, n2;
+	uint64_t c[2], cnosym;
+	Trans ttr;
 
-	Move k;
+	switch (coord->type) {
+	case COMP_COORD:
+		if (offtrans != NULL)
+			*offtrans = uf;
 
-	n = 1;
-	next[0] = i;
-	cphtr_left_cosets[i] = c;
+		return indexers_getind(coord->i, cube);
+	case SYM_COORD:
+		cnosym = index_coord(coord->base[0], cube, NULL);
+		ttr = coord->transtorep[cnosym];
 
-	while (n != 0) {
-		for (j = 0, n2 = 0; j < n; j++) {
-			for (k = U2; k < B3; k++) {
-				if (!moveset_htr.allowed(k))
-					continue;
-				jj = apply_move(k, (Cube){ .cp = next[j] }).cp;
+		if (offtrans != NULL)
+			*offtrans = ttr;
 
-				if (cphtr_left_cosets[jj] == -1) {
-					cphtr_left_cosets[jj] = c;
-					next2[n2++] = jj;
-				}
-			}
-		}
+		return coord->symclass[cnosym];
+	case SYMCOMP_COORD:
+		c[0] = index_coord(coord->base[0], cube, NULL);
+		cnosym = index_coord(coord->base[0]->base[0], cube, NULL);
+		ttr = coord->base[0]->transtorep[cnosym];
+		c[1] = index_coord(coord->base[1], cube, NULL);
+		c[1] = trans_coord(coord->base[1], ttr, c[1]);
 
-		for (j = 0; j < n2; j++)
-			next[j] = next2[j];
-		n = n2;
+		if (offtrans != NULL)
+			*offtrans = ttr;
+
+		return c[0] * coord->base[1]->max + c[1];
+	default:
+		break;
 	}
+
+	return coord->max; /* Only reached in case of error */
 }
 
-static void
-init_cphtr_right_cosets_color(int i, int d)
+uint64_t
+move_coord(Coordinate *coord, Move m, uint64_t ind, Trans *offtrans)
 {
-	int cp;
-	unsigned int j;
+	uint64_t i[2], M;
+	Trans ttr;
 
-	cphtr_right_rep[d] = i;
-	for (j = 0; j < FACTORIAL8; j++) {
-		if (cphtr_left_cosets[j] == 0) {
-			cp = compose((Cube){.cp = i}, (Cube){.cp = j}).cp;
-			cphtr_right_cosets[cp] = d;
-		}
-	}
-}
+	/* Some safety checks should be done here, but for performance   *
+	 * reasons we'd rather do them before calling this function.     *
+	 * We should check if coord is generated.                        */
 
-static void
-init_cpud_separate()
-{
-	unsigned int ui;
-	int i, co[8];
+	switch (coord->type) {
+	case COMP_COORD:
+		if (offtrans != NULL)
+			*offtrans = uf;
+
+		return coord->mtable[m][ind];
+	case SYM_COORD:
+		ttr = coord->ttrep_move[m][ind];
 
-	for (ui = 0; ui < FACTORIAL8; ui++) {
-		for (i = 0; i < 8; i++)
-			co[i] = what_corner_at((Cube){.cp=ui},i)>UBR ?  1 : 0;
-		cpud_separate_ind[ui] = subset_to_index(co, 8, 4);
-		cpud_separate_ant[cpud_separate_ind[ui]] = ui;
+		if (offtrans != NULL)
+			*offtrans = ttr;
+
+		return coord->mtable[m][ind];
+	case SYMCOMP_COORD:
+		M = coord->base[1]->max;
+		i[0] = ind / M;
+		i[1] = ind % M;
+		ttr = coord->base[0]->ttrep_move[m][i[0]];
+		i[0] = coord->base[0]->mtable[m][i[0]];
+		i[1] = coord->base[1]->mtable[m][i[1]];
+		i[1] = coord->base[1]->ttable[ttr][i[1]];
+
+		if (offtrans != NULL)
+			*offtrans = ttr;
+
+		return i[0] * M + i[1];
+	default:
+		break;
 	}
+
+	return coord->max; /* Only reached in case of error */
 }
 
-static void
-init_cornershtrfin()
+bool
+test_coord(Coordinate *coord)
 {
-	unsigned int i, j;
-	int n, c;
-	Move m;
+	uint64_t ui, uj;
+	Cube c;
 
-	for (i = 0; i < FACTORIAL8; i++)
-		cornershtrfin_ind[i] = -1;
-	cornershtrfin_ind[0] = 0;
+	if (coord->type != COMP_COORD) {
+		fprintf(stderr, "Can only test COMP_COORD\n");
+		return false;
+	}
 
-	/* 10-pass, I think 5 is enough, but just in case */
-	n = 1;
-	for (i = 0; i < 10; i++) {
-		for (j = 0; j < FACTORIAL8; j++) {
-			if (cornershtrfin_ind[j] == -1)
-				continue;
-			for (m = U; m < NMOVES; m++) {
-				if (moveset_htr.allowed(m)) {
-					c = cp_mtable[m][j];
-					if (cornershtrfin_ind[c] == -1) {
-						cornershtrfin_ind[c] = n;
-						cornershtrfin_ant[n] = c;
-						n++;
-					}
-				}
-			}
+	gen_coord(coord);
+	for (ui = 0; ui < coord->max; ui++) {
+		indexers_makecube(coord->i, ui, &c);
+		uj = indexers_getind(coord->i, &c);
+		if (ui != uj) {
+			fprintf(stderr, "%s: error: %" PRIu64 " different"
+			    " from %" PRIu64 "\n", coord->name, uj, ui);
+			return false;
 		}
 	}
-}
 
-void
-init_htr_eposs()
-{
-	int ep[12], ep2[12];
-	int eps_solved[4] = {UL, UR, DL, DR};
-	unsigned int i, j;
-
-	for (i = 0; i < BINOM12ON4; i++) {
-		for (j = 0; j < 12; j++)
-			ep[j] = ep2[j] = 0;
-		epos_to_partial_ep(i*24, ep, eps_solved);
-		for (j = 0; j < 8; j++)
-			ep2[j/2 + 4*(j%2)] = ep[j] ? 1 : 0;
-		htr_eposs_ind[i] = subset_to_index(ep2, 8, 4);
-		htr_eposs_ant[htr_eposs_ind[i]] = i*24;
-	}
+	fprintf(stderr, "%s: test passed\n", coord->name);
+	return true;
 }
 
-void
-init_coord()
+uint64_t
+trans_coord(Coordinate *coord, Trans t, uint64_t ind)
 {
-	static bool initialized = false;
-	if (initialized)
-		return;
-	initialized = true;
+	uint64_t i[2], M;
 
-	init_trans();
+	/* Some safety checks should be done here, but for performance   *
+	 * reasons we'd rather do them before calling this function.     *
+	 * We should check if coord is generated.                        */
 
-	init_cphtr_cosets();
-	init_cornershtrfin();
-	init_htr_eposs();
-	init_cpud_separate();
-}
+	switch (coord->type) {
+	case COMP_COORD:
+		return coord->ttable[t][ind];
+	case SYM_COORD:
+		return ind;
+	case SYMCOMP_COORD:
+		M = coord->base[1]->max;
+		i[0] = ind / M; /* Always fixed */
+		i[1] = ind % M;
+		i[1] = coord->base[1]->ttable[t][i[1]];
+		return i[0] * M + i[1];
+	default:
+		break;
+	}
 
+	return coord->max; /* Only reached in case of error */
+}
diff --git a/src/coord.h b/src/coord.h
@@ -3,26 +3,232 @@
 
 #include "trans.h"
 
-extern Coordinate       coord_eofb;
-extern Coordinate       coord_eofbepos;
-extern Coordinate       coord_coud;
-extern Coordinate       coord_cp;
-extern Coordinate       coord_cphtr;
-extern Coordinate       coord_corners;
-extern Coordinate       coord_cornershtr;
-extern Coordinate       coord_cornershtrfin;
-extern Coordinate       coord_epud;
-extern Coordinate       coord_drud;
-extern Coordinate       coord_drud_eofb;
-extern Coordinate       coord_htr_drud;
-extern Coordinate       coord_htrfin;
-extern Coordinate       coord_cpud_separate;
-
-extern int              cpud_separate_ant[BINOM8ON4];
-extern int              cpud_separate_ind[FACTORIAL8];
-extern int              cornershtrfin_ant[24*24/6];
-
-void        init_coord();
+void                    gen_coord(Coordinate *coord);
+uint64_t                index_coord(Coordinate *coord, Cube *cube,
+                            Trans *offtrans);
+uint64_t                move_coord(Coordinate *coord, Move m,
+                            uint64_t ind, Trans *offtrans);
+bool                    test_coord(Coordinate *coord);
+uint64_t                trans_coord(Coordinate *coord, Trans t, uint64_t ind);
+
+/* Base coordinates and their index functions ********************************/
+
+#ifndef COORD_C
+
+extern Coordinate coord_eofb;
+extern Coordinate coord_coud;
+extern Coordinate coord_cp;
+extern Coordinate coord_cpudsep;
+extern Coordinate coord_epos;
+extern Coordinate coord_epe;
+extern Coordinate coord_eposepe;
+extern Coordinate coord_epud;
+extern Coordinate coord_eofbepos;
+extern Coordinate coord_coud_cpudsep;
+extern Coordinate coord_eofbepos_sym16;
+extern Coordinate coord_cp_sym16;
+extern Coordinate coord_corners_sym16;
+extern Coordinate coord_drud_sym16;
+extern Coordinate coord_drudfin_noE_sym16;
+extern Coordinate coord_nxopt31;
+
+#else
+
+/* Indexers ******************************************************************/
+
+uint64_t index_eofb(Cube *cube);
+void     invindex_eofb(uint64_t ind, Cube *ret);
+Indexer
+i_eofb = {
+	.n       = POW2TO11,
+	.index   = index_eofb,
+	.to_cube = invindex_eofb,
+};
+
+uint64_t index_coud(Cube *cube);
+void     invindex_coud(uint64_t ind, Cube *ret);
+Indexer
+i_coud = {
+	.n       = POW3TO7,
+	.index   = index_coud,
+	.to_cube = invindex_coud,
+};
+
+uint64_t index_cp(Cube *cube);
+void     invindex_cp(uint64_t ind, Cube *ret);
+Indexer
+i_cp = {
+	.n       = FACTORIAL8,
+	.index   = index_cp,
+	.to_cube = invindex_cp,
+};
+
+uint64_t index_cpudsep(Cube *cube);
+void     invindex_cpudsep(uint64_t ind, Cube *ret);
+Indexer
+i_cpudsep = {
+	.n       = BINOM8ON4,
+	.index   = index_cpudsep,
+	.to_cube = invindex_cpudsep,
+};
+
+uint64_t index_epos(Cube *cube);
+void     invindex_epos(uint64_t ind, Cube *ret);
+Indexer
+i_epos = {
+	.n       = BINOM12ON4,
+	.index   = index_epos,
+	.to_cube = invindex_epos,
+};
+
+uint64_t index_epe(Cube *cube);
+void     invindex_epe(uint64_t ind, Cube *ret);
+Indexer
+i_epe = {
+	.n       = FACTORIAL4,
+	.index   = index_epe,
+	.to_cube = invindex_epe,
+};
+
+uint64_t index_eposepe(Cube *cube);
+void     invindex_eposepe(uint64_t ind, Cube *ret);
+Indexer
+i_eposepe = {
+	.n       = BINOM12ON4 * FACTORIAL4,
+	.index   = index_eposepe,
+	.to_cube = invindex_eposepe,
+};
+
+uint64_t index_epud(Cube *cube);
+void     invindex_epud(uint64_t ind, Cube *ret);
+Indexer
+i_epud = {
+	.n       = FACTORIAL8,
+	.index   = index_epud,
+	.to_cube = invindex_epud,
+};
+
+/* Composite coordinates *****************************************************/
+
+Coordinate
+coord_eofb = {
+	.name = "eofb",
+	.type = COMP_COORD,
+	.i    = {&i_eofb, NULL},
+};
+
+Coordinate
+coord_coud = {
+	.name = "coud",
+	.type = COMP_COORD,
+	.i    = {&i_coud, NULL},
+};
+
+Coordinate
+coord_cp = {
+	.name = "cp",
+	.type = COMP_COORD,
+	.i    = {&i_cp, NULL},
+};
+
+Coordinate
+coord_cpudsep = {
+	.name = "cpudsep",
+	.type = COMP_COORD,
+	.i    = {&i_cpudsep, NULL},
+};
+
+Coordinate
+coord_epos = {
+	.name = "epos",
+	.type = COMP_COORD,
+	.i    = {&i_epos, NULL},
+};
+
+Coordinate
+coord_epe = {
+	.name = "epe",
+	.type = COMP_COORD,
+	.i    = {&i_epe, NULL},
+};
+
+Coordinate
+coord_eposepe = { /* Has to be done by hand, hard compose epos + epe */
+	.name = "eposepe",
+	.type = COMP_COORD,
+	.i    = {&i_eposepe, NULL},
+};
+
+Coordinate
+coord_epud = {
+	.name = "epud",
+	.type = COMP_COORD,
+	.i    = {&i_epud, NULL},
+};
+
+Coordinate
+coord_eofbepos = {
+	.name = "eofbepos",
+	.type = COMP_COORD,
+	.i    = {&i_epos, &i_eofb, NULL},
+};
+
+Coordinate
+coord_coud_cpudsep = {
+	.name = "coud_cpudsep",
+	.type = COMP_COORD,
+	.i    = {&i_coud, &i_cpudsep, NULL},
+};
+
+/* Symcoordinates ************************************************************/
+
+Coordinate
+coord_eofbepos_sym16 = {
+	.name = "eofbepos_sym16",
+	.type = SYM_COORD,
+	.base = {&coord_eofbepos, NULL},
+	.tgrp = &tgrp_udfix,
+};
+
+Coordinate
+coord_cp_sym16 = {
+	.name = "cp_sym16",
+	.type = SYM_COORD,
+	.base = {&coord_cp, NULL},
+	.tgrp = &tgrp_udfix,
+};
+
+/* "Symcomp" coordinates *****************************************************/
+
+Coordinate
+coord_corners_sym16 = {
+	.name = "corners_sym16",
+	.type = SYMCOMP_COORD,
+	.base = {&coord_cp_sym16, &coord_coud},
+};
+
+Coordinate
+coord_drud_sym16 = {
+	.name = "drud_sym16",
+	.type = SYMCOMP_COORD,
+	.base = {&coord_eofbepos_sym16, &coord_coud},
+};
+
+Coordinate
+coord_drudfin_noE_sym16 = {
+	.name = "drudfin_noE_sym16",
+	.type = SYMCOMP_COORD,
+	.base = {&coord_cp_sym16, &coord_epud},
+};
+
+Coordinate
+coord_nxopt31 = {
+	.name = "nxopt31",
+	.type = SYMCOMP_COORD,
+	.base = {&coord_eofbepos_sym16, &coord_coud_cpudsep},
+};
+
+#endif
 
 #endif
 
diff --git a/src/cube.c b/src/cube.c
@@ -1,531 +1,121 @@
-#include "cube.h"
-
-/* Local functions ***********************************************************/
-
-static void             init_inverse();
-static bool             read_invtables_file();
-static bool             write_invtables_file();
-
-/* Tables ********************************************************************/
+#define CUBE_C
 
-static uint16_t         eo_invtable_e[POW2TO11][BINOM12ON4*FACTORIAL4];
-static uint16_t         eo_invtable_s[POW2TO11][BINOM12ON4*FACTORIAL4];
-static uint16_t         eo_invtable_m[POW2TO11][BINOM12ON4*FACTORIAL4];
-static uint16_t         co_invtable[POW3TO7][FACTORIAL8];
-static uint16_t         cp_invtable[FACTORIAL8];
-static uint16_t         cpos_invtable[FACTORIAL6];
-
-/* Functions implementation **************************************************/
-
-int
-array_ep_to_epos(int *ep, int *ss)
-{
-	int epos[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-	int eps[4];
-	int i, j, is;
-
-	for (i = 0, is = 0; i < 12; i++) {
-		for (j = 0; j < 4; j++) {
-			if (ep[i] == ss[j]) {
-				eps[is++] = j;
-				epos[i] = 1;
-			}
-		}
-	}
-
-	for (i = 0; i < 4; i++)
-		swap(&epos[ss[i]], &epos[i+8]);
-
-	return 24 * subset_to_index(epos, 12, 4) + perm_to_index(eps, 4);
-}
-
-Cube
-arrays_to_cube(CubeArray *arr, PieceFilter f)
-{
-	Cube ret = {0};
-
-	static int epe_solved[4] = {FR, FL, BL, BR};
-	static int eps_solved[4] = {UL, UR, DL, DR};
-	static int epm_solved[4] = {UF, UB, DF, DB};
-
-	if (f.epose)
-		ret.epose = array_ep_to_epos(arr->ep, epe_solved);
-	if (f.eposs)
-		ret.eposs = array_ep_to_epos(arr->ep, eps_solved);
-	if (f.eposm)
-		ret.eposm = array_ep_to_epos(arr->ep, epm_solved);
-	if (f.eofb)
-		ret.eofb = digit_array_to_int(arr->eofb, 11, 2);
-	if (f.eorl)
-		ret.eorl = digit_array_to_int(arr->eorl, 11, 2);
-	if (f.eoud)
-		ret.eoud = digit_array_to_int(arr->eoud, 11, 2);
-	if (f.cp)
-		ret.cp = perm_to_index(arr->cp, 8);
-	if (f.coud)
-		ret.coud = digit_array_to_int(arr->coud, 7, 3);
-	if (f.corl)
-		ret.corl = digit_array_to_int(arr->corl, 7, 3);
-	if (f.cofb)
-		ret.cofb = digit_array_to_int(arr->cofb, 7, 3);
-	if (f.cpos)
-		ret.cpos = perm_to_index(arr->cpos, 6);
-
-	return ret;
-}
+#include "cube.h"
 
-Cube
-compose_filtered(Cube c2, Cube c1, PieceFilter f)
+void
+compose(Cube *c2, Cube *c1)
 {
-	CubeArray *arr = new_cubearray(c2, f);
-	Cube ret;
+	apply_permutation(c2->ep, c1->ep, 12);
+	apply_permutation(c2->ep, c1->eo, 12);
+	sum_arrays_mod(c2->eo, c1->eo, 12, 2);
 
-	ret = move_via_arrays(arr, c1, f);
-	free_cubearray(arr, f);
+	apply_permutation(c2->cp, c1->cp, 8);
+	apply_permutation(c2->cp, c1->co, 8);
+	sum_arrays_mod(c2->co, c1->co, 8, 3);
 
-	return ret;
+	apply_permutation(c2->xp, c1->xp, 6);
 }
 
 void
-cube_to_arrays(Cube cube, CubeArray *arr, PieceFilter f)
+copy_cube(Cube *src, Cube *dst)
 {
-	int i;
-
-	static int epe_solved[4] = {FR, FL, BL, BR};
-	static int eps_solved[4] = {UL, UR, DL, DR};
-	static int epm_solved[4] = {UF, UB, DF, DB};
-
-	if (f.epose || f.eposs || f.eposm)
-		for (i = 0; i < 12; i++)
-			arr->ep[i] = -1;
-
-	if (f.epose) 
-		epos_to_partial_ep(cube.epose, arr->ep, epe_solved); 
-	if (f.eposs) 
-		epos_to_partial_ep(cube.eposs, arr->ep, eps_solved); 
-	if (f.eposm)
-		epos_to_partial_ep(cube.eposm, arr->ep, epm_solved); 
-	if (f.eofb)
-		int_to_sum_zero_array(cube.eofb, 2, 12, arr->eofb);
-	if (f.eorl)
-		int_to_sum_zero_array(cube.eorl, 2, 12, arr->eorl);
-	if (f.eoud)
-		int_to_sum_zero_array(cube.eoud, 2, 12, arr->eoud);
-	if (f.cp)
-		index_to_perm(cube.cp, 8, arr->cp);
-	if (f.coud)
-		int_to_sum_zero_array(cube.coud, 3, 8, arr->coud);
-	if (f.corl)
-		int_to_sum_zero_array(cube.corl, 3, 8, arr->corl);
-	if (f.cofb)
-		int_to_sum_zero_array(cube.cofb, 3, 8, arr->cofb);
-	if (f.cpos)
-		index_to_perm(cube.cpos, 6, arr->cpos);
+	memcpy(dst->ep, src->ep, 12 * sizeof(int));
+	memcpy(dst->eo, src->eo, 12 * sizeof(int));
+	memcpy(dst->cp, src->cp,  8 * sizeof(int));
+	memcpy(dst->co, src->co,  8 * sizeof(int));
+	memcpy(dst->xp, src->xp,  6 * sizeof(int));
 }
 
-void
-epos_to_compatible_ep(int epos, int *ep, int *ss)
+bool
+equal(Cube *c1, Cube *c2)
 {
-	int i, j, k, other[8];
-	bool flag;
+	int i;
 
 	for (i = 0; i < 12; i++)
-		ep[i] = -1;
-
-	epos_to_partial_ep(epos, ep, ss);
-
-	for (i = 0, j = 0; i < 12; i++) {
-		flag = false;
-		for (k = 0; k < 4; k++)
-			flag = flag || (i == ss[k]);
-		if (!flag)
-			other[j++] = i;
-	}
-		
-	for (i = 0, j = 0; i < 12; i++)
-		if (ep[i] == -1)
-			ep[i] = other[j++];
-}
-
-void
-epos_to_partial_ep(int epos, int *ep, int *ss)
-{
-	int i, is, eposs[12], eps[4];
+		if (c1->ep[i] != c2->ep[i] || c1->eo[i] != c2->eo[i])
+			return false;
 
-	index_to_perm(epos % FACTORIAL4, 4, eps);
-	index_to_subset(epos / FACTORIAL4, 12, 4, eposs);
+	for (i = 0; i < 8; i++)
+		if (c1->cp[i] != c2->cp[i] || c1->co[i] != c2->co[i])
+			return false;
 
-	for (i = 0; i < 4; i++)
-		swap(&eposs[ss[i]], &eposs[i+8]);
+	for (i = 0; i < 6; i++)
+		if (c1->xp[i] != c2->xp[i])
+			return false;
 
-	for (i = 0, is = 0; i < 12; i++)
-		if (eposs[i])
-			ep[i] = ss[eps[is++]];
+	return true;
 }
 
 void
-fix_eorleoud(CubeArray *arr)
+invert_cube(Cube *cube)
 {
+	Cube aux;
 	int i;
 
+	copy_cube(cube, &aux);
+
 	for (i = 0; i < 12; i++) {
-		if ((edge_slice(i) == 0 && edge_slice(arr->ep[i]) != 0) ||
-		    (edge_slice(i) != 0 && edge_slice(arr->ep[i]) == 0)) {
-			arr->eorl[i] = 1 - arr->eofb[i];
-		} else {
-			arr->eorl[i] = arr->eofb[i];
-		}
-
-		if ((edge_slice(i) == 2 && edge_slice(arr->ep[i]) != 2) ||
-		    (edge_slice(i) != 2 && edge_slice(arr->ep[i]) == 2)) {
-			arr->eoud[i] = 1 - arr->eofb[i];
-		} else {
-			arr->eoud[i] = arr->eofb[i];
-		}
+		cube->ep[aux.ep[i]] = i;
+		cube->eo[aux.ep[i]] = aux.eo[i];
 	}
-}
-
-void
-fix_cofbcorl(CubeArray *arr)
-{
-	int i;
 
 	for (i = 0; i < 8; i++) {
-		if (i % 2 == arr->cp[i] % 2) {
-			arr->cofb[i] = arr->coud[i];
-			arr->corl[i] = arr->coud[i];
-		} else {
-			if (arr->cp[i] % 2 == 0) {
-				arr->cofb[i] = (arr->coud[i]+1)%3;
-				arr->corl[i] = (arr->coud[i]+2)%3;
-			} else {
-				arr->cofb[i] = (arr->coud[i]+2)%3;
-				arr->corl[i] = (arr->coud[i]+1)%3;
-			}
-		}
+		cube->cp[aux.cp[i]] = i;
+		cube->co[aux.cp[i]] = (3 - aux.co[i]) % 3;
 	}
-}
-
-Cube
-fourval_to_cube(int eofb, int ep, int coud, int cp)
-{
-	CubeArray *arr;
-
-	arr = new_cubearray((Cube){0}, pf_all);
-
-	index_to_perm(ep, 12, arr->ep);
-	index_to_perm(cp,  8, arr->cp);
-	int_to_sum_zero_array(eofb, 2, 12, arr->eofb);
-	int_to_sum_zero_array(coud, 3,  8, arr->coud);
 
-	/* fix parity */
-	if (perm_sign(arr->ep, 12) != perm_sign(arr->cp, 8))
-		swap(&(arr->ep[0]), &(arr->ep[1]));
-
-	fix_eorleoud(arr);
-	fix_cofbcorl(arr);
-
-	return arrays_to_cube(arr, pf_all);
-}
-
-void
-free_cubearray(CubeArray *arr, PieceFilter f)
-{
-	if (f.epose || f.eposs || f.eposm)
-		free(arr->ep);
-	if (f.eofb)
-		free(arr->eofb);
-	if (f.eorl)
-		free(arr->eorl);
-	if (f.eoud)
-		free(arr->eoud);
-	if (f.cp)
-		free(arr->cp);
-	if (f.coud)
-		free(arr->coud);
-	if (f.corl)
-		free(arr->corl);
-	if (f.cofb)
-		free(arr->cofb);
-	if (f.cpos)
-		free(arr->cpos);
-
-	free(arr);
-}
-
-Cube
-move_via_arrays(CubeArray *arr, Cube c, PieceFilter f)
-{
-	CubeArray *arrc = new_cubearray(c, f);
-	Cube ret;
-
-	if (f.epose || f.eposs || f.eposm)
-		apply_permutation(arr->ep, arrc->ep, 12);
-
-	if (f.eofb) {
-		apply_permutation(arr->ep, arrc->eofb, 12);
-		sum_arrays_mod(arr->eofb, arrc->eofb, 12, 2);
-	}
-
-	if (f.eorl) {
-		apply_permutation(arr->ep, arrc->eorl, 12);
-		sum_arrays_mod(arr->eorl, arrc->eorl, 12, 2);
-	}
-
-	if (f.eoud) {
-		apply_permutation(arr->ep, arrc->eoud, 12);
-		sum_arrays_mod(arr->eoud, arrc->eoud, 12, 2);
-	}
-
-	if (f.cp)
-		apply_permutation(arr->cp, arrc->cp, 8);
-
-	if (f.coud) {
-		apply_permutation(arr->cp, arrc->coud, 8);
-		sum_arrays_mod(arr->coud, arrc->coud, 8, 3);
-	}
-
-	if (f.corl) {
-		apply_permutation(arr->cp, arrc->corl, 8);
-		sum_arrays_mod(arr->corl, arrc->corl, 8, 3);
-	}
-
-	if (f.cofb) {
-		apply_permutation(arr->cp, arrc->cofb, 8);
-		sum_arrays_mod(arr->cofb, arrc->cofb, 8, 3);
-	}
-
-	if (f.cpos)
-		apply_permutation(arr->cpos, arrc->cpos, 6);
-
-	ret = arrays_to_cube(arrc, f);
-	free_cubearray(arrc, f);
-
-	return ret;
-}
-
-CubeArray *
-new_cubearray(Cube cube, PieceFilter f)
-{
-	CubeArray *arr = malloc(sizeof(CubeArray));
-
-	if (f.epose || f.eposs || f.eposm)
-		arr->ep   = malloc(12 * sizeof(int));
-	if (f.eofb)
-		arr->eofb = malloc(12 * sizeof(int));
-	if (f.eorl)
-		arr->eorl = malloc(12 * sizeof(int));
-	if (f.eoud)
-		arr->eoud = malloc(12 * sizeof(int));
-	if (f.cp)
-		arr->cp   = malloc(8  * sizeof(int));
-	if (f.coud)
-		arr->coud = malloc(8  * sizeof(int));
-	if (f.corl)
-		arr->corl = malloc(8  * sizeof(int));
-	if (f.cofb)
-		arr->cofb = malloc(8  * sizeof(int));
-	if (f.cpos)
-		arr->cpos = malloc(6  * sizeof(int));
-
-	cube_to_arrays(cube, arr, f);
-
-	return arr;
-}
-
-Cube
-admissible_ep(Cube cube, PieceFilter f)
-{
-	CubeArray *arr = new_cubearray(cube, f);
-	Cube ret;
-	bool used[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-	int i, j;
-
-	for (i = 0; i < 12; i++)
-		if (arr->ep[i] != -1)
-			used[arr->ep[i]] = true;
-
-	for (i = 0, j = 0; i < 12; i++) {
-		for ( ; j < 11 && used[j]; j++);
-		if (arr->ep[i] == -1)
-			arr->ep[i] = j++;
-	}
-
-	ret = arrays_to_cube(arr, pf_ep);
-	free_cubearray(arr, f);
-
-	return ret;
-}
-
-Cube
-compose(Cube c2, Cube c1)
-{
-	return compose_filtered(c2, c1, pf_all);
-}
-
-int
-edge_slice(Edge e) {
-	if (e < 0 || e > 11)
-		return -1;
-
-	if (e == FR || e == FL || e == BL || e == BR)
-		return 0;
-	if (e == UR || e == UL || e == DR || e == DL)
-		return 1;
-
-	return 2;
-}
-
-bool
-equal(Cube c1, Cube c2)
-{
-	return c1.eofb  == c2.eofb  &&
-	       c1.epose == c2.epose &&
-	       c1.eposs == c2.eposs &&
-	       c1.eposm == c2.eposm &&
-	       c1.coud  == c2.coud  &&
-	       c1.cp    == c2.cp    &&
-	       c1.cpos  == c2.cpos;
-}
-
-Cube
-inverse_cube(Cube cube)
-{
-	CubeArray inv;
-	Cube ret;
-	int i, ep[12];
-
-	for (i = 0; i < 12; i++)
-		ep[i] = where_is_edge(cube, i);
-	inv = (CubeArray){.ep = ep};
-	ret = arrays_to_cube(&inv, pf_ep);
-
-	ret.eofb = ((int)eo_invtable_e[cube.eofb][cube.epose]) |
-		   ((int)eo_invtable_m[cube.eofb][cube.eposm]) |
-		   ((int)eo_invtable_s[cube.eofb][cube.eposs]);
-	ret.eorl = ((int)eo_invtable_e[cube.eorl][cube.epose]) |
-		   ((int)eo_invtable_m[cube.eorl][cube.eposm]) |
-		   ((int)eo_invtable_s[cube.eorl][cube.eposs]);
-	ret.eoud = ((int)eo_invtable_e[cube.eoud][cube.epose]) |
-		   ((int)eo_invtable_m[cube.eoud][cube.eposm]) |
-		   ((int)eo_invtable_s[cube.eoud][cube.eposs]);
-	ret.cp   = cp_invtable[cube.cp];
-	ret.cpos = cpos_invtable[cube.cpos];
-	ret.coud = co_invtable[cube.coud][cube.cp];
-	ret.corl = co_invtable[cube.corl][cube.cp];
-	ret.cofb = co_invtable[cube.cofb][cube.cp];
-
-	return ret;
+	for (i = 0; i < 6; i++)
+		cube->xp[aux.xp[i]] = i;
 }
 
 bool
-is_admissible(Cube cube) {
-
-	/* TODO: this should check consistency of different orientations */
-	/* check also that centers are opposite and admissible */
-
-	CubeArray *a = new_cubearray(cube, pf_all);
-	int parity;
+is_admissible(Cube *c) {
 	bool perm;
+	int sign, i;
+	int sum_e, sum_c;
 
-	perm   = is_perm(a->ep,  12)  &&
-	         is_perm(a->cp,   8)  &&
-	         is_perm(a->cpos, 6);
-	parity = perm_sign(a->ep,  12) +
-	         perm_sign(a->cp,   8) +
-	         perm_sign(a->cpos, 6);
-
-	free_cubearray(a, pf_all);
-
-	return perm && parity % 2 == 0;
-}
+	perm = is_perm(c->ep, 12) && is_perm(c->cp, 8) && is_perm(c->xp, 6);
 
-bool
-is_solved(Cube cube)
-{
-	return equal(cube, (Cube){0});
-}
+	sign = perm_sign(c->ep,12) + perm_sign(c->cp,8) + perm_sign(c->xp,6);
 
-bool
-is_block_solved(Cube cube, Block block)
-{
-	int i;
-
-	for (i = 0; i < 12; i++)
-		if (block.edge[i] && !is_solved_edge(cube, i))
-			return false;
-	for (i = 0; i < 8; i++)
-		if (block.corner[i] && !is_solved_corner(cube, i))
-			return false;
-	for (i = 0; i < 6; i++)
-		if (block.center[i] && !is_solved_center(cube, i))
+	for (i = 0, sum_e = 0; i < 12; i++)
+		if (c->eo[i] > 1)
 			return false;
+		else
+			sum_e += c->eo[i];
 
-	return true;
-}
+	for (i = 0, sum_c = 0; i < 8; i++)
+		if (c->co[i] > 2)
+			return false;
+		else
+			sum_c += c->co[i];
 
-bool
-is_solved_center(Cube cube, Center c)
-{
-	return what_center_at(cube, c) == c;
+	return (perm && sign % 2 == 0 && sum_e % 2 == 0 && sum_c % 2 == 0);
 }
 
 bool
-is_solved_corner(Cube cube, Corner c)
+is_solved(Cube *cube)
 {
-	return what_corner_at(cube, c) == c &&
-	       what_orientation_corner(cube.coud, c);
-}
+	Cube solved_cube;
+	make_solved(&solved_cube);
 
-bool
-is_solved_edge(Cube cube, Edge e)
-{
-	return what_edge_at(cube, e) == e &&
-	       what_orientation_edge(cube.eofb, e);
+	return equal(cube, &solved_cube);
 }
 
-int
-piece_orientation(Cube cube, int piece, char *orientation)
+void
+make_solved(Cube *cube)
 {
-	int arr[12], n, b, x;
-
-	if (!strcmp(orientation, "eofb")) {
-		x = cube.eofb;
-		n = 12;
-		b = 2;
-	} else if (!strcmp(orientation, "eorl")) {
-		x = cube.eorl;
-		n = 12;
-		b = 2;
-	} else if (!strcmp(orientation, "eoud")) {
-		x = cube.eoud;
-		n = 12;
-		b = 2;
-	} else if (!strcmp(orientation, "coud")) {
-		x = cube.coud;
-		n = 8;
-		b = 3;
-	} else if (!strcmp(orientation, "corl")) {
-		x = cube.corl;
-		n = 8;
-		b = 3;
-	} else if (!strcmp(orientation, "cofb")) {
-		x = cube.cofb;
-		n = 8;
-		b = 3;
-	} else {
-		return -1;
-	}
-
-	int_to_sum_zero_array(x, b, n, arr);
-	if (piece < n)
-		return arr[piece];
+	static int sorted[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
 
-	return -1;
+	memcpy(cube->ep, sorted, 12 * sizeof(int));
+	memset(cube->eo, 0,      12 * sizeof(int));
+	memcpy(cube->cp, sorted,  8 * sizeof(int));
+	memset(cube->co, 0,       8 * sizeof(int));
+	memcpy(cube->xp, sorted,  6 * sizeof(int));
 }
 
 void
-print_cube(Cube cube)
+print_cube(Cube *cube)
 {
 	static char edge_string[12][7] = {
 		[UF] = "UF", [UL] = "UL", [UB] = "UB", [UR] = "UR",
@@ -545,388 +135,22 @@ print_cube(Cube cube)
 	};
 
 	for (int i = 0; i < 12; i++)
-		printf(" %s ", edge_string[what_edge_at(cube, i)]);
+		printf(" %s ", edge_string[cube->ep[i]]);
 	printf("\n");
 
 	for (int i = 0; i < 12; i++)
-		printf("  %d ", what_orientation_edge(cube.eofb, i));
+		printf("  %" PRIu8 " ", cube->eo[i]);
 	printf("\n");
 
 	for (int i = 0; i < 8; i++)
-		printf("%s ", corner_string[what_corner_at(cube, i)]);
+		printf("%s ", corner_string[cube->cp[i]]);
 	printf("\n");
 
 	for (int i = 0; i < 8; i++)
-		printf("  %d ", what_orientation_corner(cube.coud, i));
+		printf("  %" PRIu8 " ", cube->co[i]);
 	printf("\n");
 
 	for (int i = 0; i < 6; i++)
-		printf("  %s ", center_string[what_center_at(cube, i)]);
+		printf("  %s ", center_string[cube->xp[i]]);
 	printf("\n");
 }
-
-Center
-what_center_at(Cube cube, Center c)
-{
-	static bool initialized = false;
-	static Center aux[FACTORIAL6][6];
-	static int i;
-	static unsigned int ui;
-	static CubeArray *arr;
-
-	if (!initialized) {
-		for (ui = 0; ui < FACTORIAL6; ui++) {
-			arr = new_cubearray((Cube){.cpos = ui}, pf_cpos);
-			for (i = 0; i < 6; i++)
-				aux[ui][i] = arr->cpos[i];
-			free_cubearray(arr, pf_cpos);
-		}
-
-		initialized = true;
-	}
-
-	return aux[cube.cpos][c];
-}
-
-Corner
-what_corner_at(Cube cube, Corner c)
-{
-	int i;
-	unsigned int ui;
-	CubeArray *arr;
-
-	static bool initialized = false;
-	static Corner aux[FACTORIAL8][8];
-
-	if (!initialized) {
-		for (ui = 0; ui < FACTORIAL8; ui++) {
-			arr = new_cubearray((Cube){.cp = ui}, pf_cp);
-			for (i = 0; i < 8; i++)
-				aux[ui][i] = arr->cp[i];
-			free_cubearray(arr, pf_cp);
-		}
-
-		initialized = true;
-	}
-
-	return aux[cube.cp][c];
-}
-
-Edge
-what_edge_at(Cube cube, Edge e)
-{
-	Edge ret;
-	CubeArray *arr = new_cubearray(cube, pf_ep);
-
-	ret = arr->ep[e];
-
-	free_cubearray(arr, pf_ep);
-	return ret;
-}
-
-int
-what_orientation_corner(int co, Corner c)
-{
-	static bool initialized = false;
-	static int auxlast[POW3TO7];
-	static int auxarr[8];
-	static unsigned int ui;
-
-	if (!initialized) {
-		for (ui = 0; ui < POW3TO7; ui++) {
-			int_to_sum_zero_array(ui, 3, 8, auxarr);
-			auxlast[ui] = auxarr[7];
-		}
-
-		initialized = true;
-	}
-
-	if (c < 7)
-		return (co / powint(3, c)) % 3;
-	else
-		return auxlast[co];
-}
-
-int
-what_orientation_edge(int eo, Edge e)
-{
-	static bool initialized = false;
-	static int auxlast[POW2TO11];
-	static int auxarr[12];
-	static unsigned int ui;
-
-	if (!initialized) {
-		for (ui = 0; ui < POW2TO11; ui++) {
-			int_to_sum_zero_array(ui, 2, 12, auxarr);
-			auxlast[ui] = auxarr[11];
-		}
-
-		initialized = true;
-	}
-
-	if (e < 11)
-		return (eo & (1 << e)) ? 1 : 0;
-	else
-		return auxlast[eo];
-}
-
-Center
-where_is_center(Cube cube, Center c)
-{
-	static bool initialized = false;
-	static Center aux[FACTORIAL6][6];
-	static int i;
-	static unsigned int ui;
-	static CubeArray *arr;
-
-	if (!initialized) {
-		for (ui = 0; ui < FACTORIAL6; ui++) {
-			arr = new_cubearray((Cube){.cpos = ui}, pf_cpos);
-			for (i = 0; i < 6; i++)
-				aux[ui][arr->cpos[i]] = i;
-			free_cubearray(arr, pf_cpos);
-		}
-
-		initialized = true;
-	}
-
-	return aux[cube.cpos][c];
-}
-
-Corner
-where_is_corner(Cube cube, Corner c)
-{
-	static bool initialized = false;
-	static Corner aux[FACTORIAL8][8];
-	static int i;
-	static unsigned int ui;
-	static CubeArray *arr;
-
-	if (!initialized) {
-		for (ui = 0; ui < FACTORIAL8; ui++) {
-			arr = new_cubearray((Cube){.cp = ui}, pf_cp);
-			for (i = 0; i < 8; i++)
-				aux[ui][arr->cp[i]] = i;
-			free_cubearray(arr, pf_cp);
-		}
-
-		initialized = true;
-	}
-	return aux[cube.cp][c];
-}
-
-Edge
-where_is_edge(Cube c, Edge e)
-{
-	int r0, r1, r2;
-
-	static bool initialized = false;
-	static int aux[3][BINOM12ON4*FACTORIAL4][12];
-	static int i, j;
-	static unsigned int ui;
-	static CubeArray *arr;
-
-	if (!initialized) {
-		for (ui = 0; ui < BINOM12ON4*FACTORIAL4; ui++) {
-			for (i = 0; i < 3; i++)
-				for (j = 0; j < 12; j++)
-					aux[i][ui][j] = -1;
-				
-			arr = new_cubearray((Cube){.epose = ui}, pf_e);
-			for (i = 0; i < 12; i++)
-				if (edge_slice(arr->ep[i]) == 0)
-					aux[0][ui][arr->ep[i]] = i;
-			free_cubearray(arr, pf_e);
-
-			arr = new_cubearray((Cube){.eposs = ui}, pf_s);
-			for (i = 0; i < 12; i++)
-				if (edge_slice(arr->ep[i]) == 1)
-					aux[1][ui][arr->ep[i]] = i;
-			free_cubearray(arr, pf_s);
-
-			arr = new_cubearray((Cube){.eposm = ui}, pf_m);
-			for (i = 0; i < 12; i++)
-				if (edge_slice(arr->ep[i]) == 2)
-					aux[2][ui][arr->ep[i]] = i;
-			free_cubearray(arr, pf_m);
-		}
-
-		initialized = true;
-	}
-
-	r0 = aux[0][c.epose][e];
-	r1 = aux[1][c.eposs][e];
-	r2 = aux[2][c.eposm][e];
-	return MAX(r0, MAX(r1, r2));
-}
-
-static bool
-read_invtables_file()
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+20];
-	int b;
-	unsigned int ui, meeo, meco, mecp, mecpos;
-	bool r;
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/invtables");
-
-	if ((f = fopen(fname, "rb")) == NULL)
-		return false;
-
-	b = sizeof(uint16_t);
-	r = true;
-	meeo = BINOM12ON4*FACTORIAL4;
-	meco = FACTORIAL8;
-	mecp = FACTORIAL8;
-	mecpos = FACTORIAL6;
-
-	for (ui = 0; ui < POW2TO11; ui++) {
-		r = r && fread(eo_invtable_e[ui], b, meeo, f) == meeo;
-		r = r && fread(eo_invtable_m[ui], b, meeo, f) == meeo;
-		r = r && fread(eo_invtable_s[ui], b, meeo, f) == meeo;
-	}
-
-	for (ui = 0; ui < POW3TO7; ui++) {
-		r = r && fread(co_invtable[ui], b, meco, f) == meco;
-	}
-
-	r = r && fread(cp_invtable,   b, mecp,   f) == mecp;
-	r = r && fread(cpos_invtable, b, mecpos, f) == mecpos;
-
-	fclose(f);
-	return r;
-}
-
-static bool
-write_invtables_file()
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+20];
-	unsigned int ui, meeo, meco, mecp, mecpos;
-	int b;
-	bool r;
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/invtables");
-
-	if ((f = fopen(fname, "wb")) == NULL)
-		return false;
-
-	b = sizeof(uint16_t);
-	r = true;
-	meeo = BINOM12ON4*FACTORIAL4;
-	meco = FACTORIAL8;
-	mecp = FACTORIAL8;
-	mecpos = FACTORIAL6;
-
-	for (ui = 0; ui < POW2TO11; ui++) {
-		r = r && fwrite(eo_invtable_e[ui], b, meeo, f) == meeo;
-		r = r && fwrite(eo_invtable_m[ui], b, meeo, f) == meeo;
-		r = r && fwrite(eo_invtable_s[ui], b, meeo, f) == meeo;
-	}
-
-	for (ui = 0; ui < POW3TO7; ui++) {
-		r = r && fwrite(co_invtable[ui], b, meco, f) == meco;
-	}
-
-	r = r && fwrite(cp_invtable,   b, mecp,   f) == mecp;
-	r = r && fwrite(cpos_invtable, b, mecpos, f) == mecpos;
-
-	fclose(f);
-	return r;
-}
-
-void
-init_inverse()
-{
-	static bool initialized = false;
-	if (initialized)
-		return;
-	initialized = true;
-
-	if (read_invtables_file())
-		return;
-
-	fprintf(stderr, "Cannot load invtables, generating it\n");
-
-	CubeArray *aux, *inv;
-	Cube c;
-	int i, j, eoaux[12], eoinv[12];
-	unsigned int ui, uj;
-
-	aux = new_cubearray((Cube){0}, pf_all);
-	inv = new_cubearray((Cube){0}, pf_all);
-
-	for (ui = 0; ui < POW2TO11; ui++) {
-		int_to_sum_zero_array(ui, 2, 12, eoaux);
-		for (uj = 0; uj < BINOM12ON4*FACTORIAL4; uj++) {
-			for (j = 0; j < 12; j++)
-				eoinv[j] = 0;
-			c = (Cube){.epose = uj, .eposm = 0, .eposs = 0};
-			eoinv[FR] = eoaux[where_is_edge(c, FR)];
-			eoinv[FL] = eoaux[where_is_edge(c, FL)];
-			eoinv[BL] = eoaux[where_is_edge(c, BL)];
-			eoinv[BR] = eoaux[where_is_edge(c, BR)];
-			eo_invtable_e[ui][uj] = digit_array_to_int(eoinv,11,2);
- 
-			for (j = 0; j < 12; j++)
-				eoinv[j] = 0;
-			c = (Cube){.epose = 0, .eposm = uj, .eposs = 0};
-			eoinv[UF] = eoaux[where_is_edge(c, UF)];
-			eoinv[UB] = eoaux[where_is_edge(c, UB)];
-			eoinv[DF] = eoaux[where_is_edge(c, DF)];
-			eoinv[DB] = eoaux[where_is_edge(c, DB)];
-			eo_invtable_m[ui][uj] = digit_array_to_int(eoinv,11,2);
- 
-			for (j = 0; j < 12; j++)
-				eoinv[j] = 0;
-			c = (Cube){.epose = 0, .eposm = 0, .eposs = uj};
-			eoinv[UL] = eoaux[where_is_edge(c, UL)];
-			eoinv[UR] = eoaux[where_is_edge(c, UR)];
-			eoinv[DL] = eoaux[where_is_edge(c, DL)];
-			eoinv[DR] = eoaux[where_is_edge(c, DR)];
-			eo_invtable_s[ui][uj] = digit_array_to_int(eoinv,11,2);
-		}
-	}
-
-	for (ui = 0; ui < FACTORIAL8; ui++) {
-		cube_to_arrays((Cube){.cp = ui}, aux, pf_cp);
-		for (i = 0; i < 8; i++)
-			inv->cp[aux->cp[i]] = i;
-		cp_invtable[ui] = (uint16_t)arrays_to_cube(inv, pf_cp).cp;
-
-		for (uj = 0; uj < POW3TO7; uj++) {
-			cube_to_arrays((Cube){.coud = uj}, aux, pf_coud);
-			for (i = 0; i < 8; i++)
-				inv->coud[aux->cp[i]] = (3-aux->coud[i])%3;
-			co_invtable[uj][ui] =
-			    (uint16_t)arrays_to_cube(inv, pf_coud).coud;
-		}
-	}
-	
-	for (ui = 0; ui < FACTORIAL6; ui++) {
-		cube_to_arrays((Cube){.cpos = ui}, aux, pf_cpos);
-		for (i = 0; i < 6; i++)
-			inv->cpos[aux->cpos[i]] = i;
-		cpos_invtable[ui] =
-		    (uint16_t)arrays_to_cube(inv, pf_cpos).cpos;
-	}
-
-	free_cubearray(aux, pf_all);
-	free_cubearray(inv, pf_all);
-
-	if (!write_invtables_file())
-		fprintf(stderr, "Error writing invtables\n");
-}
-
-void
-init_cube()
-{
-	init_inverse();
-}
diff --git a/src/cube.h b/src/cube.h
@@ -3,44 +3,18 @@
 
 #include <stdio.h>
 
+#include "cubetypes.h"
 #include "env.h"
-#include "pf.h"
 #include "utils.h"
 
-Cube        admissible_ep(Cube cube, PieceFilter f);
-int         array_ep_to_epos(int *ep, int *eps_solved);
-Cube        arrays_to_cube(CubeArray *arr, PieceFilter f);
-Cube        compose(Cube c2, Cube c1); /* Use c2 as an alg on c1 */
-Cube        compose_filtered(Cube c2, Cube c1, PieceFilter f);
-void        cube_to_arrays(Cube cube, CubeArray *arr, PieceFilter f);
-int         edge_slice(Edge e); /* E=0, S=1, M=2 */
-bool        equal(Cube c1, Cube c2);
-Cube        inverse_cube(Cube cube);
-bool        is_admissible(Cube cube);
-bool        is_solved(Cube cube);
-bool        is_block_solved(Cube cube, Block);
-bool        is_solved_center(Cube cube, Center c);
-bool        is_solved_corner(Cube cube, Corner c);
-bool        is_solved_edge(Cube cube, Edge e);
-void        epos_to_partial_ep(int epos, int *ep, int *ss);
-void        epos_to_compatible_ep(int epos, int *ep, int *ss);
-void        fix_eorleoud(CubeArray *arr);
-void        fix_cofbcorl(CubeArray *arr);
-Cube        fourval_to_cube(int eofb, int ep, int coud, int cp);
-void        free_cubearray(CubeArray *arr, PieceFilter f);
-Cube        move_via_arrays(CubeArray *arr, Cube c, PieceFilter pf);
-CubeArray * new_cubearray(Cube cube, PieceFilter f);
-void        print_cube(Cube cube);
-Center      what_center_at(Cube cube, Center c);
-Corner      what_corner_at(Cube cube, Corner c);
-Edge        what_edge_at(Cube cube, Edge e);
-int         what_orientation_corner(int co, Corner c);
-int         what_orientation_edge(int eo, Edge e);
-Center      where_is_center(Cube cube, Center c);
-Corner      where_is_corner(Cube cube, Corner c);
-Edge        where_is_edge(Cube cube, Edge e);
-
-void        init_cube();
+void        compose(Cube *c2, Cube *c1); /* Use c2 as an alg on c1 */
+void        copy_cube(Cube *src, Cube *dst);
+bool        equal(Cube *c1, Cube *c2);
+void        invert_cube(Cube *cube);
+bool        is_admissible(Cube *cube);
+bool        is_solved(Cube *cube);
+void        make_solved(Cube *cube);
+void        print_cube(Cube *cube);
 
 #endif
 
diff --git a/src/cubetypes.h b/src/cubetypes.h
@@ -10,6 +10,8 @@
 #define NROTATIONS           24
 #define entry_group_t        uint8_t /* For pruning tables */
 
+#define MAX_N_COORD          6
+
 /* Enums *********************************************************************/
 
 typedef enum
@@ -28,6 +30,12 @@ corner
 } Corner;
 
 typedef enum
+coordtype
+{
+	COMP_COORD, SYM_COORD, SYMCOMP_COORD
+} CoordType;
+
+typedef enum
 edge
 {
 	UF, UL, UB, UR,
@@ -81,28 +89,24 @@ typedef struct command            Command;
 typedef struct commandargs        CommandArgs;
 typedef struct coordinate         Coordinate;
 typedef struct cube               Cube;
-typedef struct cubearray          CubeArray;
 typedef struct dfsarg             DfsArg;
-typedef struct estimatedata       EstimateData;
+typedef struct indexer            Indexer;
+typedef struct movable            Movable;
 typedef struct moveset            Moveset;
-typedef struct piecefilter        PieceFilter;
+typedef struct pdgendata          PDGenData;
 typedef struct prunedata          PruneData;
 typedef struct solveoptions       SolveOptions;
 typedef struct step               Step;
+typedef struct stepalt            StepAlt;
 typedef struct symdata            SymData;
 typedef struct threaddatasolve    ThreadDataSolve;
 typedef struct threaddatagenpt    ThreadDataGenpt;
+typedef struct transgroup         TransGroup;
 
-typedef Cube                 (*AntiIndexer)      (uint64_t);
-typedef bool                 (*Checker)          (Cube);
-typedef uint64_t             (*CoordMover)       (Move, uint64_t);
-typedef uint64_t             (*CoordTransformer) (Trans, uint64_t);
-typedef int                  (*Estimator)        (DfsArg *);
+typedef bool                 (*Checker)          (Cube *);
 typedef bool                 (*Validator)        (Alg *);
 typedef void                 (*Exec)             (CommandArgs *);
-typedef uint64_t             (*Indexer)          (Cube);
 typedef CommandArgs *        (*ArgParser)        (int, char **);
-typedef int                  (*TransDetector)    (Cube, Trans *);
 typedef int                  (*TransFinder)      (uint64_t, Trans *);
 
 
@@ -167,83 +171,69 @@ commandargs
 struct
 coordinate
 {
-	Indexer                   index;
+	char *                    name;
+	CoordType                 type;
+	bool                      generated;
+	Indexer *                 i[99];
 	uint64_t                  max;
-	CoordMover                move;
-	CoordTransformer          transform;
-	SymData *                 sd;
-	TransFinder               tfind; /* TODO: should be easy to remove */
-	Coordinate *              base; /* TODO: part of refactor */
+	uint64_t *                mtable[NMOVES];
+	uint64_t *                ttable[NTRANS];
+	TransGroup *              tgrp;
+	Coordinate *              base[2];
+	uint64_t *                symclass;
+	uint64_t *                symrep;
+	Trans *                   transtorep;
+	Trans *                   ttrep_move[NMOVES];
+	uint64_t *                selfsim;
 };
 
 struct
 cube
 {
-	int                       epose;
-	int                       eposs;
-	int                       eposm;
-	int                       eofb;
-	int                       eorl;
-	int                       eoud;
-	int                       cp;
-	int                       coud;
-	int                       cofb;
-	int                       corl;
-	int                       cpos;
+	int                       ep[12];
+	int                       eo[12];
+	int                       cp[8];
+	int                       co[8];
+	int                       xp[6];
 };
 
 struct
-cubearray
+movable
 {
-	int *                     ep;
-	int *                     eofb;
-	int *                     eorl;
-	int *                     eoud;
-	int *                     cp;
-	int *                     coud;
-	int *                     corl;
-	int *                     cofb;
-	int *                     cpos;
+	uint64_t                  val;
+	Trans                     t;
 };
 
 struct
 dfsarg
 {
-	Step *                    step;
-	SolveOptions *            opts;
+	Cube *                    cube;
+	Movable                   ind[MAX_N_COORD];
 	Trans                     t;
-	Cube                      cube;
-	Cube                      inverse;
+	StepAlt *                 sa;
+	SolveOptions *            opts;
 	int                       d;
-	uint64_t                  badmoves;
-	uint64_t                  badmovesinv;
+	int                       bound;
 	bool                      niss;
-	Move                      last1;
-	Move                      last2;
-	Move                      last1inv;
-	Move                      last2inv;
-	EstimateData *            ed;
+	Move                      last[2];
+	Move                      lastinv[2];
 	AlgList *                 sols;
 	pthread_mutex_t *         sols_mutex;
 	Alg *                     current_alg;
 };
 
 struct
-estimatedata
+indexer
 {
-	int                       corners;
-	int                       normal_ud;
-	int                       normal_fb;
-	int                       normal_rl;
-	int                       inverse_ud;
-	int                       inverse_fb;
-	int                       inverse_rl;
-	int                       oldret;
+	int                       n;
+	uint64_t                  (*index)(Cube *);
+	void                      (*to_cube)(uint64_t, Cube *);
 };
 
 struct
 moveset
 {
+	char *                    name;
 	bool                      (*allowed)(Move);
 	bool                      (*allowed_next)(Move, Move, Move);
 	Move                      sorted_moves[NMOVES+1];
@@ -251,34 +241,24 @@ moveset
 };
 
 struct
-piecefilter
+pdgendata
 {
-	bool                      epose;
-	bool                      eposs;
-	bool                      eposm;
-	bool                      eofb;
-	bool                      eorl;
-	bool                      eoud;
-	bool                      cp;
-	bool                      coud;
-	bool                      cofb;
-	bool                      corl;
-	bool                      cpos;
+	Coordinate *              coord;
+	Moveset *                 moveset;
+	bool                      compact;
+	PruneData *               pd;
 };
 
 struct
 prunedata
 {
-	char *                    filename;
 	entry_group_t *           ptable;
-	bool                      generated;
 	uint64_t                  n;
 	Coordinate *              coord;
 	Moveset *                 moveset;
 	bool                      compact;
 	int                       base;
 	uint64_t                  count[16];
-	PruneData *               fallback;
 	uint64_t                  fbmod;
 };
 
@@ -302,19 +282,35 @@ step
 {
 	char *                    shortname;
 	char *                    name;
-	bool                      final;
-	Checker                   is_done;
-	Estimator                 estimate;
-	Checker                   ready;
+	StepAlt *                 alt[99];
+	Trans                     t[99];
 	char *                    ready_msg;
-	Validator                 is_valid;
+};
+
+struct
+stepalt
+{
+	Checker                   ready;
+	bool                      final;
 	Moveset *                 moveset;
-	Trans                     pre_trans;
-	TransDetector             detect;
-	int                       ntables;
-	PruneData *               tables[10];
+	/* Just a comment, (TODO: remove this): moveset is really a stepalt
+	 * property, because for example we may want to define a "fingertrick
+	 * friendly ZBLL" step, where we allow either <R U D> or <R U F> as
+	 * movesets (or similar) */
+	int                       n_coord;
+	Coordinate *              coord[MAX_N_COORD];
+	Trans                     coord_trans[MAX_N_COORD];
+	PruneData *               pd[MAX_N_COORD];
+	bool                      compact_pd[MAX_N_COORD];
+	Coordinate *              fallback_coord[MAX_N_COORD];
+	PruneData *               fallback_pd[MAX_N_COORD];
+	uint64_t                  fbmod[MAX_N_COORD];
+	int                       n_dbtrick;
+	int                       dbtrick[MAX_N_COORD][3];
+	Validator                 is_valid;
 };
 
+/*
 struct
 symdata
 {
@@ -328,23 +324,18 @@ symdata
 	uint64_t *                unsym;
 	Trans *                   transtorep;
 	uint64_t *                selfsim;
-	CoordTransformer          transform; /* TODO: remove, use that of base coord */
 };
+*/
+
 
 struct
 threaddatasolve
 {
+	DfsArg                    arg;
 	int                       thid;
-	Trans                     t;
-	Cube                      cube;
-	Step *                    step;
-	int                       depth;
-	SolveOptions *            opts;
 	AlgList *                 start;
 	AlgListNode **            node;
-	AlgList *                 sols;
 	pthread_mutex_t *         start_mutex;
-	pthread_mutex_t *         sols_mutex;
 };
 
 struct
@@ -359,4 +350,11 @@ threaddatagenpt
 	pthread_mutex_t *         upmutex;
 };
 
+struct
+transgroup
+{
+	int                       n;
+	Trans                     t[NTRANS];
+};
+
 #endif
diff --git a/src/env.c b/src/env.c
@@ -1,3 +1,5 @@
+#define ENV_C
+
 #include "env.h"
 
 bool initialized_env = false;
diff --git a/src/env.h b/src/env.h
@@ -8,8 +8,8 @@
 #include <unistd.h>
 #include <sys/stat.h>
 
-extern char *tabledir;
-
 void init_env();
 
+extern char *tabledir;
+
 #endif
diff --git a/src/moves.c b/src/moves.c
@@ -1,79 +1,18 @@
+#define MOVES_C
+
 #include "moves.h"
 
 /* Local functions ***********************************************************/
 
-static Cube        apply_move_cubearray(Move m, Cube cube, PieceFilter f);
 static void        cleanup_aux(Alg *alg, Alg *ret, bool inv);
-static bool        read_mtables_file();
-static bool        write_mtables_file();
 
 /* Tables and other data *****************************************************/
 
-/* Every move is translated to a an <U, x, y> alg before filling the
-   transition tables, see init_moves() */
-
-static int edge_cycle[NMOVES][12] =
-{
-	[U] = { UR, UF, UL, UB, DF, DL, DB, DR, FR, FL, BL, BR },
-	[x] = { DF, FL, UF, FR, DB, BL, UB, BR, DR, DL, UL, UR },
-	[y] = { UR, UF, UL, UB, DR, DF, DL, DB, BR, FR, FL, BL }
-};
-
-static int corner_cycle[NMOVES][8] =
-{
-	[U] = { UBR, UFR, UFL, UBL, DFR, DFL, DBL, DBR },
-	[x] = { DFR, DFL, UFL, UFR, DBR, DBL, UBL, UBR },
-	[y] = { UBR, UFR, UFL, UBL, DBR, DFR, DFL, DBL }
-};
-
-static int center_cycle[NMOVES][6] =
-{
-	[x] = { F_center, B_center, R_center, L_center, D_center, U_center },
-	[y] = { U_center, D_center, B_center, F_center, R_center, L_center }
-};
-
-static int eofb_flipped[NMOVES][12] = {
-	[x] = { [UF] = 1, [UB] = 1, [DF] = 1, [DB] = 1 },
-	[y] = { [FR] = 1, [FL] = 1, [BL] = 1, [BR] = 1 }
-};
-
-static int eorl_flipped[NMOVES][12] = {
-	[x] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
-	[y] = { [FR] = 1, [FL] = 1, [BL] = 1, [BR] = 1 }
-};
-
-static int eoud_flipped[NMOVES][12] = {
-	[U] = { [UF] = 1, [UL] = 1, [UB] = 1, [UR] = 1 },
-	[x] = { [UF] = 1, [UB] = 1, [DF] = 1, [DB] = 1 },
-	[y] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1  }
-};
-
-static int coud_flipped[NMOVES][8] = {
-	[x] = {
-		[UFR] = 2, [UBR] = 1, [UFL] = 1, [UBL] = 2,
-		[DBR] = 2, [DFR] = 1, [DBL] = 1, [DFL] = 2
-	}
-};
-
-static int corl_flipped[NMOVES][8] = {
-	[U] = { [UFR] = 1, [UBR] = 2, [UBL] = 1, [UFL] = 2 },
-	[y] = {
-		[UFR] = 1, [UBR] = 2, [UBL] = 1, [UFL] = 2,
-		[DFR] = 2, [DBR] = 1, [DBL] = 2, [DFL] = 1
-	}
-};
+/* Moves are represented as cubes and applied using compose(). Every move is *
+ * translated to a an <U, x, y> alg before filling the transition tables.    *
+ * See init_moves().                                                         */
 
-static int cofb_flipped[NMOVES][8] = {
-	[U] = { [UFR] = 2, [UBR] = 1, [UBL] = 2, [UFL] = 1 },
-	[x] = {
-		[UFR] = 1, [UBR] = 2, [UBL] = 1, [UFL] = 2,
-		[DFR] = 2, [DBR] = 1, [DBL] = 2, [DFL] = 1
-	},
-	[y] = {
-		[UFR] = 2, [UBR] = 1, [UBL] = 2, [UFL] = 1,
-		[DFR] = 1, [DBR] = 2, [DBL] = 1, [DFL] = 2
-	}
-};
+static Cube move_array[NMOVES];
 
 static char equiv_alg_string[100][NMOVES] = {
 	[NULLMOVE] = "",
@@ -137,89 +76,34 @@ static char equiv_alg_string[100][NMOVES] = {
 	[z3]  = "  y    x    yyy  "
 };
 
-/* Transition tables, to be loaded up at the beginning */
-int              epose_mtable[NMOVES][FACTORIAL12/FACTORIAL8];
-int              eposs_mtable[NMOVES][FACTORIAL12/FACTORIAL8];
-int              eposm_mtable[NMOVES][FACTORIAL12/FACTORIAL8];
-int              eofb_mtable[NMOVES][POW2TO11];
-int              eorl_mtable[NMOVES][POW2TO11];
-int              eoud_mtable[NMOVES][POW2TO11];
-int              cp_mtable[NMOVES][FACTORIAL8];
-int              coud_mtable[NMOVES][POW3TO7];
-int              cofb_mtable[NMOVES][POW3TO7];
-int              corl_mtable[NMOVES][POW3TO7];
-int              cpos_mtable[NMOVES][FACTORIAL6];
-
-
-/* Local functions implementation ********************************************/
-
-static Cube
-apply_move_cubearray(Move m, Cube cube, PieceFilter f)
-{
-	/*init_moves();*/
-
-	CubeArray m_arr = {
-		edge_cycle[m],
-		eofb_flipped[m],
-		eorl_flipped[m],
-		eoud_flipped[m],
-		corner_cycle[m],
-		coud_flipped[m],
-		corl_flipped[m],
-		cofb_flipped[m],
-		center_cycle[m]
-	};
-
-	return move_via_arrays(&m_arr, cube, f);
-}
 
 /* Public functions **********************************************************/
 
-Cube
-apply_alg_generic(Alg *alg, Cube c, PieceFilter f, bool a)
+void
+apply_alg(Alg *alg, Cube *cube)
 {
-	Cube ret = {0};
+	Cube aux;
 	int i;
 
+	copy_cube(cube, &aux);
+	make_solved(cube);
+
 	for (i = 0; i < alg->len; i++)
 		if (alg->inv[i])
-			ret = a ? apply_move(alg->move[i], ret) :
-			          apply_move_cubearray(alg->move[i], ret, f);
+			apply_move(alg->move[i], cube);
 
-	ret = compose_filtered(c, inverse_cube(ret), f);
+	invert_cube(cube);
+	compose(&aux, cube);
 
 	for (i = 0; i < alg->len; i++)
 		if (!alg->inv[i])
-			ret = a ? apply_move(alg->move[i], ret) :
-			          apply_move_cubearray(alg->move[i], ret, f);
-
-	return ret;
+			apply_move(alg->move[i], cube);
 }
 
-Cube
-apply_alg(Alg *alg, Cube cube)
-{
-	return apply_alg_generic(alg, cube, pf_all, true);
-}
-
-Cube
-apply_move(Move m, Cube cube)
+void
+apply_move(Move m, Cube *cube)
 {
-	/*init_moves();*/
-
-	return (Cube) {
-		.epose = epose_mtable[m][cube.epose],
-		.eposs = eposs_mtable[m][cube.eposs],
-		.eposm = eposm_mtable[m][cube.eposm],
-		.eofb  = eofb_mtable[m][cube.eofb],
-		.eorl  = eorl_mtable[m][cube.eorl],
-		.eoud  = eoud_mtable[m][cube.eoud],
-		.coud  = coud_mtable[m][cube.coud],
-		.cofb  = cofb_mtable[m][cube.cofb],
-		.corl  = corl_mtable[m][cube.corl],
-		.cp    = cp_mtable[m][cube.cp],
-		.cpos  = cpos_mtable[m][cube.cpos]
-	};
+	compose(&move_array[m], cube);
 }
 
 Alg *
@@ -279,31 +163,27 @@ cleanup_aux(Alg *alg, Alg *ret, bool inv)
 {
 	int i, j;
 	Cube c, d;
-	Move m, mm;
+	Move m;
 	Alg *equiv_alg;
 	
-	c = (Cube){0};
+	make_solved(&c);
 	for (i = 0; i < alg->len; i++) {
 		if (alg->inv[i] != inv)
 			continue;
 
 		equiv_alg = new_alg(equiv_alg_string[alg->move[i]]);
 
-		for (j = 0; j < equiv_alg->len; j++) {
-			m = equiv_alg->move[j];
-			if (m == U) {
-				mm = 3*what_center_at(c, U_center) + 1;
-				append_move(ret, mm, inv);
-			} else {
-				c = apply_move(m, c);
-			}
-		}
+		for (j = 0; j < equiv_alg->len; j++)
+			if (equiv_alg->move[j] == U)
+				append_move(ret, 3 * c.xp[U_center] + 1, inv);
+			else
+				apply_move(equiv_alg->move[j], &c);
 
 		free_alg(equiv_alg);
 	}
 
 	m = NULLMOVE;
-	switch (what_center_at(c, F_center)) {
+	switch (c.xp[F_center]) {
 	case U_center:
 		m = x3;
 		break;
@@ -317,7 +197,7 @@ cleanup_aux(Alg *alg, Alg *ret, bool inv)
 		m = y3;
 		break;
 	case B_center:
-		if (what_center_at(c, U_center) == U_center)
+		if (c.xp[U_center] == U_center)
 			m = y2;
 		else
 			m = x2;
@@ -325,120 +205,24 @@ cleanup_aux(Alg *alg, Alg *ret, bool inv)
 	default:
 		break;
 	}
-	d = apply_move(m, (Cube){0});
+
+	make_solved(&d);
+	apply_move(m, &d);
 	if (m != NULLMOVE)
 		append_move(ret, m, inv);
 
 	m = NULLMOVE;
-	if (what_center_at(c, U_center) == what_center_at(d, D_center)) {
+	if (c.xp[U_center] == d.xp[D_center]) {
 		m = z2;
-	} else if (what_center_at(c, U_center) == what_center_at(d, R_center)) {
+	} else if (c.xp[U_center] == d.xp[R_center]) {
 		m = z3;
-	} else if (what_center_at(c, U_center) == what_center_at(d, L_center)) {
+	} else if (c.xp[U_center] == d.xp[L_center]) {
 		m = z;
 	}
 	if (m != NULLMOVE)
 		append_move(ret, m, inv);
 }
 
-static bool
-read_mtables_file()
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+20];
-	int m, b = sizeof(int);
-	bool r = true;
-
-	/* Table sizes, used for reading and writing files */
-	uint64_t me[11] = {
-		[0]  = FACTORIAL12/FACTORIAL8,
-		[1]  = FACTORIAL12/FACTORIAL8,
-		[2]  = FACTORIAL12/FACTORIAL8,
-		[3]  = POW2TO11,
-		[4]  = POW2TO11,
-		[5]  = POW2TO11,
-		[6]  = FACTORIAL8,
-		[7]  = POW3TO7,
-		[8]  = POW3TO7,
-		[9]  = POW3TO7,
-		[10] = FACTORIAL6
-	};
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/mtables");
-
-	if ((f = fopen(fname, "rb")) == NULL)
-		return false;
-
-	for (m = 0; m < NMOVES; m++) {
-		r = r && fread(epose_mtable[m], b, me[0],  f) == me[0];
-		r = r && fread(eposs_mtable[m], b, me[1],  f) == me[1];
-		r = r && fread(eposm_mtable[m], b, me[2],  f) == me[2];
-		r = r && fread(eofb_mtable[m],  b, me[3],  f) == me[3];
-		r = r && fread(eorl_mtable[m],  b, me[4],  f) == me[4];
-		r = r && fread(eoud_mtable[m],  b, me[5],  f) == me[5];
-		r = r && fread(cp_mtable[m],    b, me[6],  f) == me[6];
-		r = r && fread(coud_mtable[m],  b, me[7],  f) == me[7];
-		r = r && fread(corl_mtable[m],  b, me[8],  f) == me[8];
-		r = r && fread(cofb_mtable[m],  b, me[9],  f) == me[9];
-		r = r && fread(cpos_mtable[m],  b, me[10], f) == me[10];
-	}
-
-	fclose(f);
-	return r;
-}
-
-static bool
-write_mtables_file()
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+20];
-	int m, b = sizeof(int);
-	bool r = true;
-
-	/* Table sizes, used for reading and writing files */
-	uint64_t me[11] = {
-		[0]  = FACTORIAL12/FACTORIAL8,
-		[1]  = FACTORIAL12/FACTORIAL8,
-		[2]  = FACTORIAL12/FACTORIAL8,
-		[3]  = POW2TO11,
-		[4]  = POW2TO11,
-		[5]  = POW2TO11,
-		[6]  = FACTORIAL8,
-		[7]  = POW3TO7,
-		[8]  = POW3TO7,
-		[9]  = POW3TO7,
-		[10] = FACTORIAL6
-	};
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/mtables");
-
-	if ((f = fopen(fname, "wb")) == NULL)
-		return false;
-
-	for (m = 0; m < NMOVES; m++) {
-		r = r && fwrite(epose_mtable[m], b, me[0],  f) == me[0];
-		r = r && fwrite(eposs_mtable[m], b, me[1],  f) == me[1];
-		r = r && fwrite(eposm_mtable[m], b, me[2],  f) == me[2];
-		r = r && fwrite(eofb_mtable[m],  b, me[3],  f) == me[3];
-		r = r && fwrite(eorl_mtable[m],  b, me[4],  f) == me[4];
-		r = r && fwrite(eoud_mtable[m],  b, me[5],  f) == me[5];
-		r = r && fwrite(cp_mtable[m],    b, me[6],  f) == me[6];
-		r = r && fwrite(coud_mtable[m],  b, me[7],  f) == me[7];
-		r = r && fwrite(corl_mtable[m],  b, me[8],  f) == me[8];
-		r = r && fwrite(cofb_mtable[m],  b, me[9],  f) == me[9];
-		r = r && fwrite(cpos_mtable[m],  b, me[10], f) == me[10];
-	}
-
-	fclose(f);
-	return r;
-}
-
 void
 init_moves() {
 	static bool initialized = false;
@@ -446,101 +230,54 @@ init_moves() {
 		return;
 	initialized = true;
 
-	Cube c;
-	CubeArray arrs;
-	int i;
-	unsigned int ui;
 	Move m;
 	Alg *equiv_alg[NMOVES];
 
-	init_cube();
-
-	for (i = 0; i < NMOVES; i++)
-		equiv_alg[i] = new_alg(equiv_alg_string[i]);
-
-	/* Generate all move cycles and flips; I do this regardless */
-	for (i = 0; i < NMOVES; i++) {
-		if (i == U || i == x || i == y)
-			continue;
-
-		c = apply_alg_generic(equiv_alg[i], (Cube){0}, pf_all, false);
-
-		arrs = (CubeArray) {
-			edge_cycle[i],
-			eofb_flipped[i],
-			eorl_flipped[i],
-			eoud_flipped[i],
-			corner_cycle[i],
-			coud_flipped[i],
-			corl_flipped[i],
-			cofb_flipped[i],
-			center_cycle[i]
-		};
-		cube_to_arrays(c, &arrs, pf_all);
-	}
+	static const Cube mcu = {
+		.ep = { UR, UF, UL, UB, DF, DL, DB, DR, FR, FL, BL, BR },
+		.cp = { UBR, UFR, UFL, UBL, DFR, DFL, DBL, DBR },
+	};
+	static const Cube mcx = {
+		.ep = { DF, FL, UF, FR, DB, BL, UB, BR, DR, DL, UL, UR },
+		.eo = { [UF] = 1, [UB] = 1, [DF] = 1, [DB] = 1 },
+		.cp = { DFR, DFL, UFL, UFR, DBR, DBL, UBL, UBR },
+		.co = { [UFR] = 2, [UBR] = 1, [UFL] = 1, [UBL] = 2,
+			[DBR] = 2, [DFR] = 1, [DBL] = 1, [DFL] = 2 },
+		.xp = { F_center, B_center, R_center,
+		        L_center, D_center, U_center },
+	};
+	static const Cube mcy = {
+		.ep = { UR, UF, UL, UB, DR, DF, DL, DB, BR, FR, FL, BL },
+		.eo = { [FR] = 1, [FL] = 1, [BL] = 1, [BR] = 1 },
+		.cp = { UBR, UFR, UFL, UBL, DBR, DFR, DFL, DBL },
+		.xp = { U_center, D_center, B_center,
+		        F_center, R_center, L_center },
+	};
 
-	if (read_mtables_file())
-		return;
+	move_array[U] = mcu;
+	move_array[x] = mcx;
+	move_array[y] = mcy;
 
-	fprintf(stderr, "Cannot load %s, generating it\n", "mtables"); 
+	for (m = 0; m < NMOVES; m++)
+		equiv_alg[m] = new_alg(equiv_alg_string[m]);
 
-	/* Initialize transition tables */
 	for (m = 0; m < NMOVES; m++) {
-		for (ui = 0; ui < FACTORIAL12/FACTORIAL8; ui++) {
-			c = (Cube){ .epose = ui };
-			c = apply_move_cubearray(m, c, pf_e);
-			epose_mtable[m][ui] = c.epose;
-
-			c = (Cube){ .eposs = ui };
-			c = apply_move_cubearray(m, c, pf_s);
-			eposs_mtable[m][ui] = c.eposs;
-
-			c = (Cube){ .eposm = ui };
-			c = apply_move_cubearray(m, c, pf_m);
-			eposm_mtable[m][ui] = c.eposm;
-		}
-		for (ui = 0; ui < POW2TO11; ui++ ) {
-			c = (Cube){ .eofb = ui };
-			c = apply_move_cubearray(m, c, pf_eo);
-			eofb_mtable[m][ui] = c.eofb;
-
-			c = (Cube){ .eorl = ui };
-			c = apply_move_cubearray(m, c, pf_eo);
-			eorl_mtable[m][ui] = c.eorl;
-
-			c = (Cube){ .eoud = ui };
-			c = apply_move_cubearray(m, c, pf_eo);
-			eoud_mtable[m][ui] = c.eoud;
-		}
-		for (ui = 0; ui < POW3TO7; ui++) {
-			c = (Cube){ .coud = ui };
-			c = apply_move_cubearray(m, c, pf_co);
-			coud_mtable[m][ui] = c.coud;
-
-			c = (Cube){ .corl = ui };
-			c = apply_move_cubearray(m, c, pf_co);
-			corl_mtable[m][ui] = c.corl;
-
-			c = (Cube){ .cofb = ui };
-			c = apply_move_cubearray(m, c, pf_co);
-			cofb_mtable[m][ui] = c.cofb;
-		}
-		for (ui = 0; ui < FACTORIAL8; ui++) {
-			c = (Cube){ .cp = ui };
-			c = apply_move_cubearray(m, c, pf_cp);
-			cp_mtable[m][ui] = c.cp;
-		}
-		for (ui = 0; ui < FACTORIAL6; ui++) {
-			c = (Cube){ .cpos = ui };
-			c = apply_move_cubearray(m, c, pf_cpos);
-			cpos_mtable[m][ui] = c.cpos;
+		switch (m) {
+		case NULLMOVE:
+			make_solved(&move_array[m]);
+			break;
+		case U:
+		case x:
+		case y:
+			break;
+		default:
+			make_solved(&move_array[m]);
+			apply_alg(equiv_alg[m], &move_array[m]);
+			break;
 		}
 	}
 
-	if (!write_mtables_file())
-		fprintf(stderr, "Error writing mtables\n");
-
-	for (i = 0; i < NMOVES; i++)
-		free_alg(equiv_alg[i]);
+	for (m = 0; m < NMOVES; m++)
+		free_alg(equiv_alg[m]);
 }
 
diff --git a/src/moves.h b/src/moves.h
@@ -5,24 +5,8 @@
 #include "cube.h"
 #include "env.h"
 
-/*
- * Tables are exposed to allow for faster moves in some cases.
- */
-extern int              epose_mtable[NMOVES][FACTORIAL12/FACTORIAL8];
-extern int              eposs_mtable[NMOVES][FACTORIAL12/FACTORIAL8];
-extern int              eposm_mtable[NMOVES][FACTORIAL12/FACTORIAL8];
-extern int              eofb_mtable[NMOVES][POW2TO11];
-extern int              eorl_mtable[NMOVES][POW2TO11];
-extern int              eoud_mtable[NMOVES][POW2TO11];
-extern int              cp_mtable[NMOVES][FACTORIAL8];
-extern int              coud_mtable[NMOVES][POW3TO7];
-extern int              cofb_mtable[NMOVES][POW3TO7];
-extern int              corl_mtable[NMOVES][POW3TO7];
-extern int              cpos_mtable[NMOVES][FACTORIAL6];
-
-Cube        apply_alg(Alg *alg, Cube cube);
-Cube        apply_alg_generic(Alg *alg, Cube c, PieceFilter f, bool a);
-Cube        apply_move(Move m, Cube cube);
+void        apply_alg(Alg *alg, Cube *cube);
+void        apply_move(Move m, Cube *cube);
 Alg *       cleanup(Alg *alg);
 
 void        init_moves();
diff --git a/src/pf.c b/src/pf.c
@@ -1,95 +0,0 @@
-#include "pf.h"
-
-PieceFilter
-pf_all = {
-	.epose = true,
-	.eposs = true,
-	.eposm = true,
-	.eofb  = true,
-	.eorl  = true,
-	.eoud  = true,
-	.cp    = true,
-	.cofb  = true,
-	.corl  = true,
-	.coud  = true,
-	.cpos  = true
-};
-
-PieceFilter
-pf_4val = {
-	.epose = true,
-	.eposs = true,
-	.eposm = true,
-	.eofb  = true,
-	.coud  = true,
-	.cp    = true
-};
-
-PieceFilter
-pf_epcp = {
-	.epose = true,
-	.eposs = true,
-	.eposm = true,
-	.cp    = true
-};
-
-PieceFilter
-pf_cpos = {
-	.cpos  = true
-};
-
-PieceFilter
-pf_cp = {
-	.cp    = true
-};
-
-PieceFilter
-pf_ep = {
-	.epose = true,
-	.eposs = true,
-	.eposm = true
-};
-
-PieceFilter
-pf_e = {
-	.epose = true
-};
-
-PieceFilter
-pf_s = {
-	.eposs = true
-};
-
-PieceFilter
-pf_m = {
-	.eposm = true
-};
-
-PieceFilter
-pf_eo = {
-	.eofb  = true,
-	.eorl  = true,
-	.eoud  = true
-};
-
-PieceFilter
-pf_co = {
-	.cofb  = true,
-	.corl  = true,
-	.coud  = true
-};
-
-PieceFilter
-pf_coud = {
-	.coud  = true
-};
-
-PieceFilter
-pf_edges = {
-	.epose = true,
-	.eposs = true,
-	.eposm = true,
-	.eofb  = true,
-	.eorl  = true,
-	.eoud  = true
-};
diff --git a/src/pf.h b/src/pf.h
@@ -1,20 +0,0 @@
-#ifndef PF_H
-#define PF_H
-
-#include "cubetypes.h"
-
-extern PieceFilter pf_all;
-extern PieceFilter pf_4val;
-extern PieceFilter pf_epcp;
-extern PieceFilter pf_cpos;
-extern PieceFilter pf_cp;
-extern PieceFilter pf_ep;
-extern PieceFilter pf_e;
-extern PieceFilter pf_s;
-extern PieceFilter pf_m;
-extern PieceFilter pf_eo;
-extern PieceFilter pf_co;
-extern PieceFilter pf_coud;
-extern PieceFilter pf_edges;
-
-#endif
diff --git a/src/pruning.c b/src/pruning.c
@@ -1,3 +1,5 @@
+#define PRUNING_C
+
 #include "pruning.h"
 
 #define ENTRIES_PER_GROUP              (2*sizeof(entry_group_t))
@@ -10,101 +12,11 @@ static void        genptable_fixnasty(PruneData *pd, int d, int nthreads);
 static void        genptable_setbase(PruneData *pd);
 static void *      instance_bfs(void *arg);
 static void *      instance_fixnasty(void *arg);
-static void        ptable_update(PruneData *pd, Cube cube, int m);
-static void        ptable_update_index(PruneData *pd, uint64_t ind, int m);
-static int         ptableval_index(PruneData *pd, uint64_t ind);
+static void        ptable_update(PruneData *pd, uint64_t ind, int m);
 static bool        read_ptable_file(PruneData *pd);
 static bool        write_ptable_file(PruneData *pd);
 
-PruneData
-pd_eofb_HTM = {
-	.filename = "pt_eofb_HTM",
-	.coord    = &coord_eofb,
-	.moveset  = &moveset_HTM,
-};
-
-PruneData
-pd_coud_HTM = {
-	.filename = "pt_coud_HTM",
-	.coord    = &coord_coud,
-	.moveset  = &moveset_HTM,
-};
-
-PruneData
-pd_cornershtr_HTM = {
-	.filename = "pt_cornershtr_HTM",
-	.coord    = &coord_cornershtr,
-	.moveset  = &moveset_HTM,
-};
-
-PruneData
-pd_corners_HTM = {
-	.filename = "pt_corners_HTM",
-	.coord    = &coord_corners,
-	.moveset  = &moveset_HTM,
-};
-
-PruneData
-pd_drud_sym16_HTM = {
-	.filename = "pt_drud_sym16_HTM",
-	.coord    = &coord_drud_sym16,
-	.moveset  = &moveset_HTM,
-};
-
-PruneData
-pd_drud_eofb = {
-	.filename = "pt_drud_eofb",
-	.coord    = &coord_drud_eofb,
-	.moveset  = &moveset_eofb,
-};
-
-PruneData
-pd_drudfin_noE_sym16_drud = {
-	.filename = "pt_drudfin_noE_sym16_drud",
-	.coord    = &coord_drudfin_noE_sym16,
-	.moveset  = &moveset_drud,
-};
-
-PruneData
-pd_htr_drud = {
-	.filename = "pt_htr_drud",
-	.coord    = &coord_htr_drud,
-	.moveset  = &moveset_drud,
-};
-
-PruneData
-pd_htrfin_htr = {
-	.filename = "pt_htrfin_htr",
-	.coord    = &coord_htrfin,
-	.moveset  = &moveset_htr,
-};
-
-PruneData
-pd_nxopt31_HTM = {
-	.filename = "pt_nxopt31_HTM",
-	.coord    = &coord_nxopt31,
-	.moveset  = &moveset_HTM,
-
-	.compact  = true,
-	.fallback = &pd_drud_sym16_HTM,
-	.fbmod    = BINOM8ON4,
-};
-
-PruneData * all_pd[] = {
-	&pd_eofb_HTM,
-	&pd_coud_HTM,
-	&pd_cornershtr_HTM,
-	&pd_corners_HTM,
-	&pd_drud_sym16_HTM,
-	&pd_drud_eofb,
-	&pd_drudfin_noE_sym16_drud,
-	&pd_htr_drud,
-	&pd_htrfin_htr,
-	&pd_nxopt31_HTM,
-	NULL
-};
-
-/* Functions *****************************************************************/
+PDGenData *active_pdg[256];
 
 int
 findchunk(PruneData *pd, int nchunks, uint64_t i)
@@ -117,39 +29,41 @@ findchunk(PruneData *pd, int nchunks, uint64_t i)
 	return MIN(nchunks-1, (int)(i / chunksize));
 }
 
-void
-free_pd(PruneData *pd)
-{
-	if (pd->generated)
-		free(pd->ptable);
-
-	pd->generated = false;
-}
-
-void
-genptable(PruneData *pd, int nthreads)
+PruneData *
+genptable(PDGenData *pdg, int nthreads)
 {
 	bool compact;
-	int d, nchunks;
+	int d, nchunks, i;
 	uint64_t oldn, sz;
+	PruneData *pd;
+
+	for (i = 0; active_pdg[i] != NULL; i++) {
+		pd = active_pdg[i]->pd;
+		if (pd->coord == pdg->coord &&
+		    pd->moveset == pdg->moveset &&
+		    pd->compact == pdg->compact)
+			return pd;
+	}
 
-	if (pd->generated)
-		return;
+	pd = malloc(sizeof(PruneData));
+	pdg->pd = pd;
+	pd->coord   = pdg->coord;
+	pd->moveset = pdg->moveset;
+	pd->compact = pdg->compact;
 
-	/* TODO: check if memory is enough, otherwise maybe exit gracefully? */
 	sz = ptablesize(pd) * (pd->compact ? 2 : 1);
 	pd->ptable = malloc(sz * sizeof(entry_group_t));
 
-	if (read_ptable_file(pd)) {
-		pd->generated = true;
-		return;
-	}
+	gen_coord(pd->coord);
+
+	if (read_ptable_file(pd))
+		goto genptable_done;
 
 	if (nthreads < 4) {
 		fprintf(stderr,
 			"--- Warning ---\n"
 			"You are using only %d threads to generate the pruning"
-			"tables. This can take a while."
+			"tables. This can take a while.\n"
 			"Unless you did this intentionally, you should re-run"
 			"this command with `-t 4' or more.\n"
 			"---------------\n\n", nthreads
@@ -160,16 +74,16 @@ genptable(PruneData *pd, int nthreads)
 	/* For the first steps we proceed the same way for compact and not */
 	compact = pd->compact;
 	pd->compact = false;
-	pd->generated = true;
 
 	nchunks = MIN(ptablesize(pd), 100000);
-	fprintf(stderr, "Cannot load %s, generating it with %d threads\n",
-			pd->filename, nthreads); 
-
+	fprintf(stderr, "Generating pt_%s_%s with %d threads\n",
+			pd->coord->name, pd->moveset->name, nthreads); 
 
 	memset(pd->ptable, ~(uint8_t)0, ptablesize(pd)*sizeof(entry_group_t));
+	for (i = 0; i < 16; i++)
+		pd->count[i] = 0;
 
-	ptable_update(pd, (Cube){0}, 0);
+	ptable_update(pd, 0, 0);
 	pd->n = 1;
 	oldn = 0;
 	genptable_fixnasty(pd, 0, nthreads);
@@ -192,9 +106,19 @@ genptable(PruneData *pd, int nthreads)
 	genptable_setbase(pd);
 	if (compact)
 		genptable_compress(pd);
-	
+
 	if (!write_ptable_file(pd))
 		fprintf(stderr, "Error writing ptable file\n");
+
+genptable_done:
+	for (i = 0; active_pdg[i] != NULL; i++);
+	active_pdg[i] = malloc(sizeof(PDGenData));
+	active_pdg[i]->coord   = pdg->coord;
+	active_pdg[i]->moveset = pdg->moveset;
+	active_pdg[i]->compact = pdg->compact;
+	active_pdg[i]->pd      = pd;
+
+	return pd;
 }
 
 static void
@@ -245,7 +169,7 @@ genptable_compress(PruneData *pd)
 		for (j = 0; j < ENTRIES_PER_GROUP_COMPACT; j++) {
 			if (i+j >= pd->coord->max)
 				break;
-			val = ptableval_index(pd, i+j) - pd->base;
+			val = ptableval(pd, i+j) - pd->base;
 			v = (entry_group_t)MIN(3, MAX(0, val));
 			mask |= v << (2*j);
 		}
@@ -264,7 +188,7 @@ genptable_fixnasty(PruneData *pd, int d, int nthreads)
 	ThreadDataGenpt td[nthreads];
 	pthread_mutex_t *upmtx;
 
-	if (pd->coord->tfind == NULL)
+	if (pd->coord->type != SYMCOMP_COORD)
 		return;
 
 	upmtx = malloc(sizeof(pthread_mutex_t));
@@ -320,17 +244,17 @@ instance_bfs(void *arg)
 	for (i = rmin; i < rmax; i++) {
 		ichunk = findchunk(td->pd, td->nchunks, i);
 		pthread_mutex_lock(td->mutex[ichunk]);
-		pval = ptableval_index(td->pd, i);
+		pval = ptableval(td->pd, i);
 		pthread_mutex_unlock(td->mutex[ichunk]);
 		if (pval == td->d) {
 			for (j = 0; ms[j] != NULLMOVE; j++) {
-				ii = td->pd->coord->move(ms[j], i);
+				/* ii = td->pd->coord->move(ms[j], i); */
+				ii = move_coord(td->pd->coord, ms[j], i, NULL);
 				ichunk = findchunk(td->pd, td->nchunks, ii);
 				pthread_mutex_lock(td->mutex[ichunk]);
-				pval = ptableval_index(td->pd, ii);
+				pval = ptableval(td->pd, ii);
 				if (pval > td->d+1) {
-					ptable_update_index(td->pd,
-					    ii, td->d+1);
+					ptable_update(td->pd, ii, td->d+1);
 					updated++;
 				}
 				pthread_mutex_unlock(td->mutex[ichunk]);
@@ -349,13 +273,15 @@ static void *
 instance_fixnasty(void *arg)
 {
 	ThreadDataGenpt *td;
-	uint64_t i, ii, nb, blocksize, rmin, rmax, updated;
-	int j, n;
-	Trans t, aux[NTRANS];
+	uint64_t i, ii, blocksize, rmin, rmax, updated, ss, M;
+	int j;
+	Trans t;
 
 	td = (ThreadDataGenpt *)arg;
-	nb = td->pd->coord->max / td->pd->coord->base->max;
-	blocksize = (td->pd->coord->base->max / td->nthreads) * nb;
+
+	/* We know type = SYMCOMP_COORD */
+	M = td->pd->coord->base[1]->max;
+	blocksize = (td->pd->coord->base[0]->max / td->nthreads) * M;
 	rmin = ((uint64_t)td->thid) * blocksize;
 	rmax = td->thid == td->nthreads - 1 ?
 	       td->pd->coord->max :
@@ -363,16 +289,15 @@ instance_fixnasty(void *arg)
 
 	updated = 0;
 	for (i = rmin; i < rmax; i++) {
-		if (ptableval_index(td->pd, i) == td->d) {
-			if ((n = td->pd->coord->tfind(i, aux)) == 1)
-				continue;
-
-			for (j = 0; j < n; j++) {
-				if ((t = aux[j]) == uf)
+		if (ptableval(td->pd, i) == td->d) {
+			ss = td->pd->coord->base[0]->selfsim[i/M];
+			for (j = 0; j < td->pd->coord->base[0]->tgrp->n; j++) {
+				t = td->pd->coord->base[0]->tgrp->t[j];
+				if (t == uf || !(ss & ((uint64_t)1<<t)))
 					continue;
-				ii = td->pd->coord->transform(t, i);
-				if (ptableval_index(td->pd, ii) > td->d) {
-					ptable_update_index(td->pd, ii, td->d);
+				ii = trans_coord(td->pd->coord, t, i);
+				if (ptableval(td->pd, ii) > td->d) {
+					ptable_update(td->pd, ii, td->d);
 					updated++;
 				}
 			}
@@ -391,10 +316,7 @@ print_ptable(PruneData *pd)
 {
 	uint64_t i;
 
-	if (!pd->generated)
-		genptable(pd, 1); /* TODO: set default nthreads somewhere */
-		
-	printf("Table %s\n", pd->filename);
+	printf("Table %s_%s\n", pd->coord->name, pd->moveset->name);
 	printf("Base value: %d\n", pd->base);
 	for (i = 0; i < 16; i++)
 		printf("%2" PRIu64 "\t%10" PRIu64 "\n", i, pd->count[i]);
@@ -411,13 +333,7 @@ ptablesize(PruneData *pd)
 }
 
 static void
-ptable_update(PruneData *pd, Cube cube, int n)
-{
-	ptable_update_index(pd, pd->coord->index(cube), n);
-}
-
-static void
-ptable_update_index(PruneData *pd, uint64_t ind, int n)
+ptable_update(PruneData *pd, uint64_t ind, int n)
 {
 	int sh;
 	entry_group_t mask;
@@ -432,27 +348,12 @@ ptable_update_index(PruneData *pd, uint64_t ind, int n)
 }
 
 int
-ptableval(PruneData *pd, Cube cube)
-{
-	return ptableval_index(pd, pd->coord->index(cube));
-}
-
-static int
-ptableval_index(PruneData *pd, uint64_t ind)
+ptableval(PruneData *pd, uint64_t ind)
 {
 	int sh, ret;
-	entry_group_t mask;
-	uint64_t i, e;
+	uint64_t e;
 	entry_group_t m;
 
-	if (!pd->generated) {
-		fprintf(stderr, "Warning: request pruning table value"
-			" for uninitialized table %s.\n It's fine, but it"
-			" should not happen. Please report bug.\n",
-			pd->filename);
-		genptable(pd, 1); /* TODO: set default or remove this case */
-	}
-
 	if (pd->compact) {
 		e  = ENTRIES_PER_GROUP_COMPACT;
 		m  = 3;
@@ -463,19 +364,9 @@ ptableval_index(PruneData *pd, uint64_t ind)
 		sh = (ind % e) * 4;
 	}
 
-	mask = m << sh;
-	i = ind/e;
-
-	ret = (pd->ptable[i] & mask) >> sh;
-
-	if (pd->compact) {
-		if (ret)
-			ret += pd->base;
-		else
-			ret = ptableval_index(pd->fallback, ind / pd->fbmod);
-	}
+	ret = (pd->ptable[ind/e] & (m << sh)) >> sh;
 
-	return ret;
+	return pd->compact ? ret + pd->base : ret;
 }
 
 static bool
@@ -484,13 +375,15 @@ read_ptable_file(PruneData *pd)
 	init_env();
 
 	FILE *f;
-	char fname[strlen(tabledir)+100];
+	char fname[strlen(tabledir)+256];
 	int i;
 	uint64_t r;
 
 	strcpy(fname, tabledir);
-	strcat(fname, "/");
-	strcat(fname, pd->filename);
+	strcat(fname, "/pt_");
+	strcat(fname, pd->coord->name);
+	strcat(fname, "_");
+	strcat(fname, pd->moveset->name);
 
 	if ((f = fopen(fname, "rb")) == NULL)
 		return false;
@@ -511,13 +404,15 @@ write_ptable_file(PruneData *pd)
 	init_env();
 
 	FILE *f;
-	char fname[strlen(tabledir)+100];
+	char fname[strlen(tabledir)+256];
 	int i;
 	uint64_t w;
 
 	strcpy(fname, tabledir);
-	strcat(fname, "/");
-	strcat(fname, pd->filename);
+	strcat(fname, "/pt_");
+	strcat(fname, pd->coord->name);
+	strcat(fname, "_");
+	strcat(fname, pd->moveset->name);
 
 	if ((f = fopen(fname, "wb")) == NULL)
 		return false;
diff --git a/src/pruning.h b/src/pruning.h
@@ -1,26 +1,15 @@
 #ifndef PRUNING_H
 #define PRUNING_H
 
-#include "symcoord.h"
-
-extern PruneData        pd_eofb_HTM;
-extern PruneData        pd_coud_HTM;
-extern PruneData        pd_corners_HTM;
-extern PruneData        pd_cornershtr_HTM;
-extern PruneData        pd_drud_sym16_HTM;
-extern PruneData        pd_drud_eofb;
-extern PruneData        pd_drudfin_noE_sym16_drud;
-extern PruneData        pd_htr_drud;
-extern PruneData        pd_htrfin_htr;
-extern PruneData        pd_nxopt31_HTM;
-
-extern PruneData *      all_pd[];
+#include "coord.h"
 
 void        free_pd(PruneData *pd);
-void        genptable(PruneData *pd, int nthreads);
+PruneData * genptable(PDGenData *data, int nthreads);
 void        print_ptable(PruneData *pd);
 uint64_t    ptablesize(PruneData *pd);
-int         ptableval(PruneData *pd, Cube cube);
+int         ptableval(PruneData *pd, uint64_t ind);
+
+extern PDGenData *active_pdg[256];
 
 #endif
 
diff --git a/src/shell.c b/src/shell.c
@@ -1,3 +1,5 @@
+#define SHELL_C
+
 #include "shell.h"
 
 static void             cleanwhitespaces(char *line);
@@ -7,7 +9,9 @@ bool
 checkfiles()
 {
 	/* TODO: add more checks (other files, use checksum...) */
-	FILE *f;
+	/* How to check for pruning tables with new method? */
+	/* Solution: use list of steps */
+	/*
 	char fname[strlen(tabledir)+100];
 	int i;
 
@@ -20,6 +24,7 @@ checkfiles()
 		else
 			fclose(f);
 	}
+	*/
 
 	return true;
 }
@@ -143,6 +148,21 @@ main(int argc, char *argv[])
 	char *closing_cmd[1] = { "freemem" };
 
 	init_env();
+	init_trans();
+
+/*
+	Cube c;
+	make_solved(&c);
+	c.co[0] = 1;
+	c.co[6] = 2;
+	print_cube(&c);
+	apply_trans(uf_mirror, &c);
+	print_cube(&c);
+*/
+
+/*
+	test_coord(&coord_coud_cpudsep);
+*/
 
 	if (!checkfiles()) {
 		fprintf(stderr,
diff --git a/src/solve.c b/src/solve.c
@@ -1,37 +1,34 @@
+#define SOLVE_C
+
 #include "solve.h"
 
 /* Local functions ***********************************************************/
 
-static bool        allowed_next(Move move, DfsArg *arg);
+static bool        allowed_next(Move move, StepAlt *sa, Move l0, Move l1);
 static bool        cancel_niss(DfsArg *arg);
 static void        copy_dfsarg(DfsArg *src, DfsArg *dst);
 static void        dfs(DfsArg *arg);
-static void        dfs_branch(DfsArg *arg);
-static bool        dfs_check_solved(DfsArg *arg);
-static bool        dfs_switch(DfsArg *arg);
+static void        dfs_add_sol(DfsArg *arg);
 static void        dfs_niss(DfsArg *arg);
-static bool        dfs_stop(DfsArg *arg);
+static bool        dfs_move_checkstop(DfsArg *arg);
 static void *      instance_thread(void *arg);
-static void        invert_branch(DfsArg *arg);
-static void        multidfs(Cube c, Trans t, Step *s, SolveOptions *opts,
-                            AlgList *sols, int d);
+static void        multidfs(DfsArg *arg);
 static bool        niss_makes_sense(DfsArg *arg);
 static bool        solvestop(int d, int op, SolveOptions *opts, AlgList *sols);
 
 /* Local functions ***********************************************************/
 
 static bool
-allowed_next(Move m, DfsArg *arg)
+allowed_next(Move m, StepAlt *sa, Move l0, Move l1)
 {
-	bool bad, allowed, order;
+	bool allowed, order;
 	uint64_t mbit;
 
 	mbit    = ((uint64_t)1) << m;
-	bad     = mbit & arg->badmoves;
-	allowed = mbit & arg->step->moveset->mask[arg->last2][arg->last1];
-	order   = !commute(arg->last1, m) || arg->last1 < m;
+	allowed = mbit & sa->moveset->mask[l1][l0];
+	order   = !commute(l0, m) || l0 < m;
 
-	return allowed && !bad && order;
+	return allowed && order;
 }
 
 static bool
@@ -41,20 +38,20 @@ cancel_niss(DfsArg *arg)
 	Move i1, i2;
 	bool p, p1, p2, q, q1, q2;
 
-	if (arg->last1inv == NULLMOVE)
+	if (arg->lastinv[0] == NULLMOVE)
 		return false;
 
-	ms = arg->step->moveset;
-	i1 = inverse_move(arg->last1inv);
-	i2 = inverse_move(arg->last2inv);
+	ms = arg->sa->moveset;
+	i1 = inverse_move(arg->lastinv[0]);
+	i2 = inverse_move(arg->lastinv[1]);
 
-	p1 = !ms->allowed_next(arg->last2, arg->last1, i1);
-	p2 = !ms->allowed_next(arg->last2, i1, arg->last1);
-	p = p1 || (commute(i1, arg->last1) && p2);
+	p1 = !ms->allowed_next(arg->last[1], arg->last[0], i1);
+	p2 = !ms->allowed_next(arg->last[1], i1, arg->last[0]);
+	p = p1 || (commute(i1, arg->last[0]) && p2);
 
-	q1 = !ms->allowed_next(arg->last2, arg->last1, i2);
-	q2 = !ms->allowed_next(arg->last2, i2, arg->last1);
-	q = q1 || (commute(i2, arg->last1) && q2);
+	q1 = !ms->allowed_next(arg->last[1], arg->last[0], i2);
+	q2 = !ms->allowed_next(arg->last[1], i2, arg->last[0]);
+	q = q1 || (commute(i2, arg->last[0]) && q2);
 
 	return p || (commute(i1, i2) && q);
 }
@@ -62,142 +59,145 @@ cancel_niss(DfsArg *arg)
 static void
 copy_dfsarg(DfsArg *src, DfsArg *dst)
 {
-	dst->step          = src->step;
-	dst->opts          = src->opts;
-	dst->t             = src->t;
-	dst->cube          = src->cube;
-	dst->inverse       = src->inverse;
-	dst->d             = src->d;
-	dst->badmoves      = src->badmoves;
-	dst->badmovesinv   = src->badmovesinv;
-	dst->niss          = src->niss;
-	dst->last1         = src->last1;
-	dst->last2         = src->last2;
-	dst->last1inv      = src->last1inv;
-	dst->last2inv      = src->last2inv;
-	dst->sols          = src->sols;
-	dst->sols_mutex    = src->sols_mutex;
-	dst->current_alg   = src->current_alg;
-
-	copy_estimatedata(src->ed, dst->ed);
-}
-
-static void
-dfs(DfsArg *arg)
-{
-	bool sw = false;
-
-	if (dfs_stop(arg))
-		return;
-
-	if (dfs_check_solved(arg))
-		return;
-
-	if (arg->step->final && (sw = dfs_switch(arg)))
-		invert_branch(arg);
-	dfs_branch(arg);
+	int i;
 
-	if (arg->opts->can_niss && !arg->niss && niss_makes_sense(arg))
-		dfs_niss(arg);
+	dst->cube        = src->cube;
+	dst->t           = src->t;
+	dst->sa          = src->sa;
+	dst->opts        = src->opts;
+	dst->d           = src->d;
+	dst->bound       = src->bound; /* In theory not needed */
+	dst->niss        = src->niss;
+	dst->sols        = src->sols;
+	dst->sols_mutex  = src->sols_mutex;
+	dst->current_alg = src->current_alg;
+
+	for (i = 0; i < 2; i++) {
+		dst->last[i]    = src->last[i];
+		dst->lastinv[i] = src->lastinv[i];
+	}
 
-	if (sw)
-		invert_branch(arg);
+	for (i = 0; i < src->sa->n_coord; i++) {
+		dst->ind[i].val = src->ind[i].val;
+		dst->ind[i].t   = src->ind[i].t;
+	}
 }
 
 static void
-dfs_branch(DfsArg *arg)
+dfs(DfsArg *arg)
 {
 	int i;
 	Move m;
-	DfsArg *newarg;
-
-	newarg = malloc(sizeof(DfsArg));
-	newarg->ed = malloc(sizeof(EstimateData));
+	DfsArg newarg;
 
-	for (i = 0; arg->step->moveset->sorted_moves[i] != NULLMOVE; i++) {
-		m = arg->step->moveset->sorted_moves[i];
-		if (allowed_next(m, arg)) {
-			copy_dfsarg(arg, newarg);
-			newarg->last2 = arg->last1;
-			newarg->last1 = m;
-			newarg->cube  = apply_move(m, arg->cube);
-			append_move(arg->current_alg, m, newarg->niss);
+	if (dfs_move_checkstop(arg))
+		return;
 
-			dfs(newarg);
+	if (arg->bound == 0) {
+		if (arg->current_alg->len == arg->d)
+			dfs_add_sol(arg);
+		return;
+	}
 
+	for (i = 0; arg->sa->moveset->sorted_moves[i] != NULLMOVE; i++) {
+		m = arg->sa->moveset->sorted_moves[i];
+		if (allowed_next(m, arg->sa, arg->last[0], arg->last[1])) {
+			copy_dfsarg(arg, &newarg);
+			newarg.last[1] = arg->last[0];
+			newarg.last[0] = m;
+			append_move(arg->current_alg, m, newarg.niss);
+			dfs(&newarg);
 			arg->current_alg->len--;
 		}
 	}
 
-	free(newarg->ed);
-	free(newarg);
+	if (niss_makes_sense(arg))
+		dfs_niss(arg);
 }
 
-static bool
-dfs_check_solved(DfsArg *arg)
+static void
+dfs_add_sol(DfsArg *arg)
 {
-	if (!arg->step->is_done(arg->cube))
-		return false;
-
-	if (arg->current_alg->len == arg->d) {
-		if ((arg->step->is_valid(arg->current_alg) || arg->opts->all)
-		    && (!arg->step->final || !cancel_niss(arg))) {
-
-			pthread_mutex_lock(arg->sols_mutex);
+	bool valid, accepted, nisscanc;
 
-			if (arg->sols->len < arg->opts->max_solutions) {
-				append_alg(arg->sols, arg->current_alg);
+	valid = arg->sa->is_valid==NULL || arg->sa->is_valid(arg->current_alg);
+	accepted = valid || arg->opts->all;
+	nisscanc = arg->sa->final && cancel_niss(arg);
 
-				transform_alg(
-				    inverse_trans(arg->t), 
-				    arg->sols->last->alg
-				);
-				if (arg->step->final)
-					inplace(unniss, arg->sols->last->alg);
-
-				if (arg->opts->verbose)
-					print_alg(arg->sols->last->alg, false);
-			}
+	if (accepted && !nisscanc) {
+		pthread_mutex_lock(arg->sols_mutex);
 
-			pthread_mutex_unlock(arg->sols_mutex);
+		if (arg->sols->len < arg->opts->max_solutions) {
+			append_alg(arg->sols, arg->current_alg);
+			transform_alg(
+			    inverse_trans(arg->t), arg->sols->last->alg);
+			if (arg->opts->verbose)
+				print_alg(arg->sols->last->alg, false);
 		}
-	}
 
-	return true;
+		pthread_mutex_unlock(arg->sols_mutex);
+	}
 }
 
 static void
 dfs_niss(DfsArg *arg)
 {
-	DfsArg *newarg;
-
-	newarg = malloc(sizeof(DfsArg));
-	newarg->ed = malloc(sizeof(EstimateData));
-
-	copy_dfsarg(arg, newarg);
-	swapmove(&(newarg->last1), &(newarg->last1inv));
-	swapmove(&(newarg->last2), &(newarg->last2inv));
-	newarg->niss = !(arg->niss);
-	newarg->cube = inverse_cube(arg->cube);
-
-	dfs(newarg);
-
-	free(newarg->ed);
-	free(newarg);
+	DfsArg newarg;
+	Alg *inv;
+	Cube *c;
+
+	copy_dfsarg(arg, &newarg);
+
+	/* Invert current alg and scramble */
+	newarg.cube = malloc(sizeof(Cube));
+	inv = inverse_alg(arg->current_alg);
+	c = malloc(sizeof(Cube));
+	make_solved(newarg.cube);
+	apply_alg(inv, newarg.cube);
+	copy_cube(arg->cube, c);
+	invert_cube(c);
+	compose(c, newarg.cube);
+
+	/* New indexes */
+	compute_ind(newarg.sa, newarg.cube, newarg.ind);
+
+	swapmove(&(newarg.last[0]), &(newarg.lastinv[0]));
+	swapmove(&(newarg.last[1]), &(newarg.lastinv[1]));
+	newarg.niss = !(arg->niss);
+
+	dfs(&newarg);
+
+	free_alg(inv);
+	free(c);
+	free(newarg.cube);
 }
 
 static bool
-dfs_stop(DfsArg *arg)
+dfs_move_checkstop(DfsArg *arg)
 {
-	int lowerbound;
 	bool b;
+	int i, goal;
+	Move mm;
+	Trans tt = uf; /* Avoid uninitialized warning */
+
+	/* Moving */
+	if (arg->last[0] != NULLMOVE) {
+		for (i = 0; i < arg->sa->n_coord; i++) {
+			mm = transform_move(arg->ind[i].t, arg->last[0]);
+			arg->ind[i].val = move_coord(arg->sa->coord[i],
+			    mm, arg->ind[i].val, &tt);
+			arg->ind[i].t = transform_trans(tt, arg->ind[i].t);
+		}
+	}
 
-	lowerbound = arg->step->estimate(arg);
+	/* Computing bound for coordinates */
+	goal  = arg->d - arg->current_alg->len;
+	arg->bound = estimate_stepalt(arg->sa, arg->ind, goal);
 	if (arg->opts->can_niss && !arg->niss)
-		lowerbound = MIN(1, lowerbound);
+		arg->bound = MIN(1, arg->bound);
 
-	if (arg->current_alg->len + lowerbound > arg->d) {
-		 b = true;
+	if (arg->bound > goal) {
+		b = true;
 	} else {
 		pthread_mutex_lock(arg->sols_mutex);
 		b = arg->sols->len >= arg->opts->max_solutions;
@@ -207,37 +207,12 @@ dfs_stop(DfsArg *arg)
 	return b;
 }
 
-static bool
-dfs_switch(DfsArg *arg)
-{
-	int i, bn, bi;
-
-	bn = 0;
-	for (i = 0; arg->step->moveset->sorted_moves[i] != NULLMOVE; i++)
-		if (allowed_next(arg->step->moveset->sorted_moves[i], arg))
-			bn++;
-	
-	swapmove(&(arg->last1), &(arg->last1inv));
-	swapmove(&(arg->last2), &(arg->last2inv));
-	swapu64(&(arg->badmoves), &(arg->badmovesinv));
-
-	bi = 0;
-	for (i = 0; arg->step->moveset->sorted_moves[i] != NULLMOVE; i++)
-		if (allowed_next(arg->step->moveset->sorted_moves[i], arg))
-			bi++;
-	
-	swapmove(&(arg->last1), &(arg->last1inv));
-	swapmove(&(arg->last2), &(arg->last2inv));
-	swapu64(&(arg->badmoves), &(arg->badmovesinv));
-
-	return bi < bn;
-}
-
 static void *
 instance_thread(void *arg)
 {
-	bool b;
+	bool b, inv;
 	Cube c;
+	Move m;
 	ThreadDataSolve *td;
 	AlgListNode *node;
 	DfsArg darg;
@@ -257,68 +232,46 @@ instance_thread(void *arg)
 		if (b)
 			break;
 
-		c = node->alg->inv[0] ?
-		    apply_move(node->alg->move[0], inverse_cube(td->cube)) :
-		    apply_move(node->alg->move[0], td->cube);
-
-		darg.step            = td->step;
-		darg.opts            = td->opts;
-		darg.t               = td->t;
-		darg.cube            = c;
-		darg.d               = td->depth;
-		darg.niss            = node->alg->inv[0];
-		darg.last1           = node->alg->move[0];
-		darg.last2           = NULLMOVE;
-		darg.last1inv        = NULLMOVE;
-		darg.last2inv        = NULLMOVE;
-		darg.sols            = td->sols;
-		darg.sols_mutex      = td->sols_mutex;
+		inv = node->alg->inv[0];
+		m = node->alg->move[0];
+
+		copy_cube(td->arg.cube, &c);
+		if (inv)
+			invert_cube(&c);
+
+		copy_dfsarg(&td->arg, &darg);
+		compute_ind(td->arg.sa, &c, darg.ind);
+		darg.cube            = &c;
+
+		darg.niss            = inv;
+		darg.last[0]         = m;
+		darg.last[1]         = NULLMOVE;
+		darg.lastinv[0]      = NULLMOVE;
+		darg.lastinv[1]      = NULLMOVE;
 		darg.current_alg     = new_alg("");
-		append_move(darg.current_alg, node->alg->move[0],
-		            node->alg->inv[0]);
-		darg.ed              = malloc(sizeof(EstimateData));
-		reset_estimatedata(darg.ed);
-		darg.badmoves        = 0;
-		darg.badmovesinv     = 0;
+		append_move(darg.current_alg, m, inv);
 
 		dfs(&darg);
 
 		free_alg(darg.current_alg);
-		free(darg.ed);
 	}
 
 	return NULL;
 }
 
 static void
-invert_branch(DfsArg *arg)
-{
-	Cube aux;
-
-	aux = arg->cube;
-	arg->cube = is_solved(arg->inverse) ?
-	            inverse_cube(arg->cube) : arg->inverse;
-	arg->inverse = aux;
-
-	swapu64(&(arg->badmoves), &(arg->badmovesinv));
-	arg->niss = !(arg->niss);
-	swapmove(&(arg->last1), &(arg->last1inv));
-	swapmove(&(arg->last2), &(arg->last2inv));
-	invert_estimatedata(arg->ed);
-}
-
-static void
-multidfs(Cube c, Trans tr, Step *s, SolveOptions *opts, AlgList *sols, int d)
+multidfs(DfsArg *arg)
 {
 	int i;
+	Cube local_cube;
 	Alg *alg;
 	AlgList *start;
 	AlgListNode **node;
-	pthread_t t[opts->nthreads];
-	ThreadDataSolve td[opts->nthreads];
+	pthread_t t[arg->opts->nthreads];
+	ThreadDataSolve td[arg->opts->nthreads];
 	pthread_mutex_t *start_mutex, *sols_mutex;
 
-	node  = malloc(sizeof(AlgListNode *));
+	node        = malloc(sizeof(AlgListNode *));
 	start_mutex = malloc(sizeof(pthread_mutex_t));
 	sols_mutex  = malloc(sizeof(pthread_mutex_t));
 
@@ -326,11 +279,11 @@ multidfs(Cube c, Trans tr, Step *s, SolveOptions *opts, AlgList *sols, int d)
 	pthread_mutex_init(start_mutex, NULL);
 	pthread_mutex_init(sols_mutex,  NULL);
 
-	for (i = 0; s->moveset->sorted_moves[i] != NULLMOVE; i++) {
+	for (i = 0; arg->sa->moveset->sorted_moves[i] != NULLMOVE; i++) {
 		alg = new_alg("");
-		append_move(alg, s->moveset->sorted_moves[i], false);
+		append_move(alg, arg->sa->moveset->sorted_moves[i], false);
 		append_alg(start, alg);
-		if (opts->can_niss) {
+		if (arg->opts->can_niss && !arg->sa->final) {
 			alg->inv[0] = true;
 			append_alg(start, alg);
 		}
@@ -338,22 +291,22 @@ multidfs(Cube c, Trans tr, Step *s, SolveOptions *opts, AlgList *sols, int d)
 	}
 	*node = start->first;
 
-	for (i = 0; i < opts->nthreads; i++) {
-		td[i].thid          = i;
-		td[i].t             = tr;
-		td[i].cube          = c;
-		td[i].step          = s;
-		td[i].depth         = d;
-		td[i].opts          = opts;
-		td[i].start         = start;
-		td[i].node          = node;
-		td[i].sols          = sols;
-		td[i].start_mutex   = start_mutex;
-		td[i].sols_mutex    = sols_mutex;
+	copy_cube(arg->cube, &local_cube);
+
+	for (i = 0; i < arg->opts->nthreads; i++) {
+		copy_dfsarg(arg, &(td[i].arg));
+		td[i].arg.cube       = &local_cube;
+		td[i].arg.sols_mutex = sols_mutex;
+
+		td[i].thid           = i;
+		td[i].start          = start;
+		td[i].node           = node;
+		td[i].start_mutex    = start_mutex;
+
 		pthread_create(&t[i], NULL, instance_thread, &td[i]);
 	}
 
-	for (i = 0; i < opts->nthreads; i++)
+	for (i = 0; i < arg->opts->nthreads; i++)
 		pthread_join(t[i], NULL);
 
 	free_alglist(start);
@@ -367,8 +320,13 @@ niss_makes_sense(DfsArg *arg)
 {
 	Cube testcube;
 
-	testcube = apply_move(inverse_move(arg->last1), (Cube){0});
-	return arg->current_alg->len == 0 || !arg->step->is_done(testcube);
+	if (arg->sa->final || arg->niss || !arg->opts->can_niss)
+		return false;
+
+	make_solved(&testcube);
+	apply_move(inverse_move(arg->last[0]), &testcube);
+	return arg->current_alg->len == 0 ||
+	    estimate_stepalt(arg->sa, arg->ind, 0) > 0;
 }
 
 static bool
@@ -386,62 +344,84 @@ solvestop(int d, int op, SolveOptions *opts, AlgList *sols)
 /* Public functions **********************************************************/
 
 AlgList *
-solve(Cube cube, Step *step, SolveOptions *opts)
+solve(Cube *cube, Step *step, SolveOptions *opts)
 {
-	bool ready;
-	int i, d, op, nt;
-	AlgList *sols;
-	Cube c;
-	Trans tt[NTRANS];
+	int i, d, op;
+	bool ready[99], one_ready, zerosol;
+	Movable ind[99][10];
+	AlgList *s;
+	Cube *c[99];
+	DfsArg arg[99];
 
 	prepare_step(step, opts);
-
-	if (step->detect != NULL) {
-		nt = step->detect(cube, tt);
-	} else {
-		tt[0] = step->pre_trans;
-		ready = step->ready == NULL ||
-		        step->ready(apply_trans(tt[0], cube));
-		nt = ready ? 1 : 0;
+	s = new_alglist();
+
+	for (i = 0, one_ready = false; step->alt[i] != NULL; i++) {
+		c[i] = malloc(sizeof(Cube));
+		copy_cube(cube, c[i]);
+		apply_trans(step->t[i], c[i]);
+
+		arg[i].cube = c[i];
+		arg[i].t    = step->t[i];
+		arg[i].sa   = step->alt[i];
+		arg[i].opts = opts;
+		arg[i].sols = s;
+
+		if ((ready[i] = step->alt[i]->ready(c[i]))) {
+			one_ready = true;
+			/* Only for local use for 0 moves solutions */
+			compute_ind(step->alt[i], c[i], ind[i]);
+		}
 	}
-
-	sols = new_alglist();
-
-	if (nt == 0) {
+	if (!one_ready) {
 		fprintf(stderr, "Cube not ready for solving step: ");
 		fprintf(stderr, "%s\n", step->ready_msg);
-		return sols;
+		return s;
 	}
 
-	if (opts->min_moves == 0) {
-		for (i = 0; i < nt; i++) {
-			c = apply_trans(tt[i], cube);
-			if (step->is_done(c)) {
-				append_alg(sols, new_alg(""));
-				return sols;
-			}
+	/* If the empty moves sequence is a solution for one of the
+	 * alternatives, all longer solutions will be discarded, so we may
+	 * just set its ready[] value to false. If the solution is accepted
+	 * we append it and start searching from d = 1. */
+	for (i = 0, zerosol = false; step->alt[i] != NULL; i++) {
+		if (ready[i] && estimate_stepalt(step->alt[i],ind[i],0) == 0) {
+			ready[i] = false;
+			zerosol = true;
 		}
 	}
+	if (zerosol && opts->min_moves == 0) {
+		append_alg(s, new_alg(""));
+		opts->min_moves = 1;
+		if (opts->verbose)
+			printf("Step is already solved"
+			    "(empty alg is a solution)\n");
+	}
 
-	op = -1;
-	for (d = opts->min_moves; !solvestop(d, op, opts, sols); d++) {
+	for (d = opts->min_moves, op = -1; !solvestop(d, op, opts, s); d++) {
 		if (opts->verbose)
 			fprintf(stderr, "Searching depth %d\n", d);
 
-		for (i = 0; i < nt && !solvestop(d, op, opts, sols); i++) {
-			c = apply_trans(tt[i], cube);
-			multidfs(c, tt[i], step, opts, sols, d);
-			if (sols->len > 0 && op == -1)
+		for (i=0; step->alt[i]!=NULL && !solvestop(d,op,opts,s); i++) {
+			if (!ready[i])
+				continue;
+
+			arg[i].d = d;
+			multidfs(&arg[i]);
+
+			if (s->len > 0 && op == -1)
 				op = d;
 		}
 	}
 
-	return sols;
+	for (i = 0; step->alt[i] != NULL; i++)
+		free(c[i]);
+
+	return s;
 }
 
 /* TODO: make more general! */
 Alg *
-solve_2phase(Cube cube, int nthreads)
+solve_2phase(Cube *cube, int nthreads)
 {
 	int bestlen, newb;
 	Alg *bestalg, *ret;
@@ -466,18 +446,19 @@ solve_2phase(Cube cube, int nthreads)
 	opts2.can_niss      = false;
 	opts2.verbose       = false;
 
-	/* We skip step1 if it is solved on any axis */
-	if (drany_HTM.is_done(cube)) {
+	/* We skip step1 if it is solved on U/D */
+	if (check_drud(cube)) {
 		sols1 = new_alglist();
 		append_alg(sols1, new_alg(""));
 	} else {
-		sols1 = solve(cube, &drany_HTM, &opts1);
+		sols1 = solve(cube, &drud_HTM, &opts1);
 	}
 	bestalg = new_alg("");
 	bestlen = 999;
 	for (i = sols1->first; i != NULL; i = i->next) {
-		c = apply_alg(i->alg, cube);
-		sols2 = solve(c, &dranyfin_DR, &opts2);
+		copy_cube(cube, &c);
+		apply_alg(i->alg, &c);
+		sols2 = solve(&c, &dranyfin_DR, &opts2);
 		
 		if (sols2->len > 0) {
 			newb = i->alg->len + sols2->first->alg->len;
diff --git a/src/solve.h b/src/solve.h
@@ -5,7 +5,7 @@
 #include "steps.h"
 #include "trans.h"
 
-AlgList *   solve(Cube cube, Step *step, SolveOptions *opts);
-Alg *       solve_2phase(Cube cube, int nthreads);
+AlgList *   solve(Cube *cube, Step *step, SolveOptions *opts);
+Alg *       solve_2phase(Cube *cube, int nthreads);
 
 #endif
diff --git a/src/steps.c b/src/steps.c
@@ -1,1372 +1,112 @@
-#include "steps.h"
-
-#define UPDATECHECKSTOP(a, b, c)     if ((a=(MAX((a),(b))))>(c)) return (a);
-
-/* Checkers, estimators and validators ***************************************/
-
-static bool             check_centers(Cube cube);
-static bool             check_coud_HTM(Cube cube);
-static bool             check_coud_URF(Cube cube);
-static bool             check_corners_HTM(Cube cube);
-static bool             check_corners_URF(Cube cube);
-static bool             check_cornershtr(Cube cube);
-static bool             check_eofb(Cube cube);
-static bool             check_drud(Cube cube);
-static bool             check_htr(Cube cube);
-
-static int              estimate_eofb_HTM(DfsArg *arg);
-static int              estimate_coud_HTM(DfsArg *arg);
-static int              estimate_coud_URF(DfsArg *arg);
-static int              estimate_corners_HTM(DfsArg *arg);
-static int              estimate_cornershtr_HTM(DfsArg *arg);
-static int              estimate_corners_URF(DfsArg *arg);
-static int              estimate_cornershtr_URF(DfsArg *arg);
-static int              estimate_drud_HTM(DfsArg *arg);
-static int              estimate_drud_eofb(DfsArg *arg);
-static int              estimate_dr_eofb(DfsArg *arg);
-static int              estimate_drudfin_drud(DfsArg *arg);
-static int              estimate_htr_drud(DfsArg *arg);
-static int              estimate_htrfin_htr(DfsArg *arg);
-static int              estimate_nxopt31_HTM(DfsArg *arg);
-static int              estimate_light_HTM(DfsArg *arg);
-
-static int              estimate_nxoptlike(DfsArg *arg, PruneData *pd);
-
-static bool             always_valid(Alg *alg);
-static bool             validate_singlecw_ending(Alg *alg);
-
-/* Pre-transformation detectors **********************************************/
-
-static int              detect_pretrans_eofb(Cube cube, Trans *ret);
-static int              detect_pretrans_drud(Cube cube, Trans *ret);
-static int              detect_pretrans_void_3axis(Cube cube, Trans *ret);
-
-/* Messages for when cube is not ready ***************************************/
-
-static char check_centers_msg[100] = "cube must be oriented (centers solved)";
-static char check_eo_msg[100]      = "EO must be solved on given axis";
-static char check_dr_msg[100]      = "DR must be solved on given axis";
-static char check_htr_msg[100]     = "HTR must be solved";
-static char check_drany_msg[100]   = "DR must be solved on at least one axis";
-
-/* Steps *********************************************************************/
-
-/* Optimal solvers *******************/
-
-Step
-optimal_HTM = {
-	.shortname = "optimal",
-	.name      = "Optimal solve (in HTM)",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_nxopt31_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
-	.ntables   = 2,
-};
-
-Step
-optimal_light_HTM = {
-	.shortname = "light",
-	.name      = "Optimal solve (in HTM), small table (500Mb RAM total)",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_light_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_drud_sym16_HTM, &pd_corners_HTM},
-	.ntables   = 2,
-};
-
-/* Optimal after EO ******************/
-
-Step
-eofin_eo = {
-	.shortname = "eofin",
-	.name      = "Optimal solve after EO without breaking EO (detected)",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_nxopt31_HTM,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_eofb,
-
-	.detect    = detect_pretrans_eofb,
-
-	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
-	.ntables   = 2,
-};
-
-Step
-eofbfin_eofb = {
-	.shortname = "eofbfin",
-	.name      = "Optimal after EO on F/B without breaking EO",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_nxopt31_HTM,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
-	.ntables   = 2,
-};
-
-Step
-eorlfin_eorl = {
-	.shortname = "eorlfin",
-	.name      = "Optimal after EO on R/L without breaking EO",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_nxopt31_HTM,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = ur,
-
-	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
-	.ntables   = 2,
-};
-
-Step
-eoudfin_eoud = {
-	.shortname = "eoudfin",
-	.name      = "Optimal after EO on U/D without breaking EO",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_nxopt31_HTM,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_nxopt31_HTM, &pd_corners_HTM},
-	.ntables   = 2,
-};
-
-/* EO steps **************************/
-Step
-eoany_HTM = {
-	.shortname = "eo",
-	.name      = "EO on any axis",
-
-	.final     = false,
-	.is_done   = check_eofb,
-	.estimate  = estimate_eofb_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.detect    = detect_pretrans_void_3axis,
-
-	.tables    = {&pd_eofb_HTM},
-	.ntables   = 1,
-};
-
-Step
-eofb_HTM = {
-	.shortname = "eofb",
-	.name      = "EO on F/B",
-
-	.final     = false,
-	.is_done   = check_eofb,
-	.estimate  = estimate_eofb_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_eofb_HTM},
-	.ntables   = 1,
-};
-
-Step
-eorl_HTM = {
-	.shortname = "eorl",
-	.name      = "EO on R/L",
-
-	.final     = false,
-	.is_done   = check_eofb,
-	.estimate  = estimate_eofb_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = ur,
-
-	.tables    = {&pd_eofb_HTM},
-	.ntables   = 1,
-};
-
-Step
-eoud_HTM = {
-	.shortname = "eoud",
-	.name      = "EO on U/D",
-
-	.final     = false,
-	.is_done   = check_eofb,
-	.estimate  = estimate_eofb_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_eofb_HTM},
-	.ntables   = 1,
-};
-
-/* CO steps **************************/
-Step
-coany_HTM = {
-	.shortname = "co",
-	.name      = "CO on any axis",
-
-	.final     = false,
-	.is_done   = check_coud_HTM,
-	.estimate  = estimate_coud_HTM,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.detect    = detect_pretrans_void_3axis,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-coud_HTM = {
-	.shortname = "coud",
-	.name      = "CO on U/D",
-
-	.final     = false,
-	.is_done   = check_coud_HTM,
-	.estimate  = estimate_coud_HTM,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-corl_HTM = {
-	.shortname = "corl",
-	.name      = "CO on R/L",
-
-	.final     = false,
-	.is_done   = check_coud_HTM,
-	.estimate  = estimate_coud_HTM,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = rf,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-cofb_HTM = {
-	.shortname = "cofb",
-	.name      = "CO on F/B",
-
-	.final     = false,
-	.is_done   = check_coud_HTM,
-	.estimate  = estimate_coud_HTM,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-coany_URF = {
-	.shortname = "co-URF",
-	.name      = "CO any axis (URF moveset)",
-
-	.final     = false,
-	.is_done   = check_coud_URF,
-	.estimate  = estimate_coud_URF,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_URF,
-
-	.detect    = detect_pretrans_void_3axis,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-coud_URF = {
-	.shortname = "coud-URF",
-	.name      = "CO on U/D (URF moveset)",
-
-	.final     = false,
-	.is_done   = check_coud_URF,
-	.estimate  = estimate_coud_URF,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_URF,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-corl_URF = {
-	.shortname = "corl-URF",
-	.name      = "CO on R/L (URF moveset)",
-
-	.final     = false,
-	.is_done   = check_coud_URF,
-	.estimate  = estimate_coud_URF,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_URF,
-
-	.pre_trans = rf,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-Step
-cofb_URF = {
-	.shortname = "cofb-URF",
-	.name      = "CO on F/B (URF moveset)",
-
-	.final     = false,
-	.is_done   = check_coud_URF,
-	.estimate  = estimate_coud_URF,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_URF,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_coud_HTM},
-	.ntables   = 1,
-};
-
-/* Misc corner steps *****************/
-Step
-cornershtr_HTM = {
-	.shortname = "chtr",
-	.name      = "Solve corners to HTR state",
-
-	.final     = false,
-	.is_done   = check_cornershtr,
-	.estimate  = estimate_cornershtr_HTM,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_cornershtr_HTM},
-	.ntables   = 1,
-};
-
-Step
-cornershtr_URF = {
-	.shortname = "chtr-URF",
-	.name      = "Solve corners to HTR state (URF moveset)",
-
-	.final     = false,
-	.is_done   = check_cornershtr,
-	.estimate  = estimate_cornershtr_URF,
-	.ready     = NULL,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_URF,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_cornershtr_HTM},
-	.ntables   = 1,
-};
-
-Step
-corners_HTM = {
-	.shortname = "corners",
-	.name      = "Solve corners",
-
-	.final     = true,
-	.is_done   = check_corners_HTM,
-	.estimate  = estimate_corners_HTM,
-	.ready     = NULL,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_corners_HTM},
-	.ntables   = 1,
-};
-
-Step
-corners_URF = {
-	.shortname = "corners-URF",
-	.name      = "Solve corners (URF moveset)",
-
-	.final     = true, /* TODO: check if this works with reorient */
-	.is_done   = check_corners_URF,
-	.estimate  = estimate_corners_URF,
-	.ready     = NULL,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_URF,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_corners_HTM},
-	.ntables   = 1,
-};
-
-/* DR steps **************************/
-Step
-drany_HTM = {
-	.shortname = "dr",
-	.name      = "DR on any axis",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.detect    = detect_pretrans_void_3axis,
-
-	.tables    = {&pd_drud_sym16_HTM},
-	.ntables   = 1,
-};
-
-Step
-drud_HTM = {
-	.shortname = "drud",
-	.name      = "DR on U/D",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_drud_sym16_HTM},
-	.ntables   = 1,
-};
-
-Step
-drrl_HTM = {
-	.shortname = "drrl",
-	.name      = "DR on R/L",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = rf,
-
-	.tables    = {&pd_drud_sym16_HTM},
-	.ntables   = 1,
-};
-
-Step
-drfb_HTM = {
-	.shortname = "drfb",
-	.name      = "DR on F/B",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_HTM,
-	.ready     = check_centers,
-	.ready_msg = check_centers_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_HTM,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_drud_sym16_HTM},
-	.ntables   = 1,
-};
-
-/* DR from EO */
-Step
-dr_eo = {
-	.shortname = "dr-eo",
-	.name      = "DR without breaking EO (automatically detected)",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_dr_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.detect    = detect_pretrans_eofb,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-dr_eofb = {
-	.shortname = "dr-eofb",
-	.name      = "DR on U/D or R/L without breaking EO on F/B",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_dr_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-dr_eorl = {
-	.shortname = "dr-eorl",
-	.name      = "DR on U/D or F/B without breaking EO on R/L",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_dr_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = ur,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-dr_eoud = {
-	.shortname = "dr-eoud",
-	.name      = "DR on R/L or F/B without breaking EO on U/D",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_dr_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-drud_eofb = {
-	.shortname = "drud-eofb",
-	.name      = "DR on U/D without breaking EO on F/B",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-drrl_eofb = {
-	.shortname = "drrl-eofb",
-	.name      = "DR on R/L without breaking EO on F/B",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = rf,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-drud_eorl = {
-	.shortname = "drud-eorl",
-	.name      = "DR on U/D without breaking EO on R/L",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = ur,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-drfb_eorl = {
-	.shortname = "drfb-eorl",
-	.name      = "DR on F/B without breaking EO on R/L",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = fr,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-drfb_eoud = {
-	.shortname = "drfb-eoud",
-	.name      = "DR on F/B without breaking EO on U/D",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-Step
-drrl_eoud = {
-	.shortname = "drrl-eoud",
-	.name      = "DR on R/L without breaking EO on U/D",
-
-	.final     = false,
-	.is_done   = check_drud,
-	.estimate  = estimate_drud_eofb,
-	.ready     = check_eofb,
-	.ready_msg = check_eo_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_eofb,
-
-	.pre_trans = rd,
-
-	.tables    = {&pd_drud_eofb},
-	.ntables   = 1,
-};
-
-/* DR finish steps */
-Step
-dranyfin_DR = {
-	.shortname = "drfin",
-	.name      = "DR finish on any axis without breaking DR",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_drudfin_drud,
-	.ready     = check_drud,
-	.ready_msg = check_drany_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_drud,
-
-	.detect    = detect_pretrans_drud,
-
-	.tables    = {&pd_drudfin_noE_sym16_drud},
-	.ntables   = 1,
-};
-
-Step
-drudfin_drud = {
-	.shortname = "drudfin",
-	.name      = "DR finish on U/D without breaking DR",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_drudfin_drud,
-	.ready     = check_drud,
-	.ready_msg = check_dr_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_drud,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_drudfin_noE_sym16_drud},
-	.ntables   = 1,
-};
-
-Step
-drrlfin_drrl = {
-	.shortname = "drrlfin",
-	.name      = "DR finish on R/L without breaking DR",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_drudfin_drud,
-	.ready     = check_drud,
-	.ready_msg = check_dr_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_drud,
-
-	.pre_trans = rf,
-
-	.tables    = {&pd_drudfin_noE_sym16_drud},
-	.ntables   = 1,
-};
-
-Step
-drfbfin_drfb = {
-	.shortname = "drfbfin",
-	.name      = "DR finish on F/B without breaking DR",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_drudfin_drud,
-	.ready     = check_drud,
-	.ready_msg = check_dr_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_drud,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_drudfin_noE_sym16_drud},
-	.ntables   = 1,
-};
-
-/* HTR from DR */
-Step
-htr_any = {
-	.shortname = "htr",
-	.name      = "HTR from DR",
-
-	.final     = false,
-	.is_done   = check_htr,
-	.estimate  = estimate_htr_drud,
-	.ready     = check_drud,
-	.ready_msg = check_drany_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_drud,
+#define STEPS_C
 
-	.detect    = detect_pretrans_drud,
-
-	.tables    = {&pd_htr_drud},
-	.ntables   = 1,
-};
-
-Step
-htr_drud = {
-	.shortname = "htr-drud",
-	.name      = "HTR from DR on U/D",
-
-	.final     = false,
-	.is_done   = check_htr,
-	.estimate  = estimate_htr_drud,
-	.ready     = check_drud,
-	.ready_msg = check_dr_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_drud,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_htr_drud},
-	.ntables   = 1,
-};
-
-Step
-htr_drrl = {
-	.shortname = "htr-drrl",
-	.name      = "HTR from DR on R/L",
-
-	.final     = false,
-	.is_done   = check_htr,
-	.estimate  = estimate_htr_drud,
-	.ready     = check_drud,
-	.ready_msg = check_dr_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_drud,
-
-	.pre_trans = rf,
-
-	.tables    = {&pd_htr_drud},
-	.ntables   = 1,
-};
-
-Step
-htr_drfb = {
-	.shortname = "htr-drfb",
-	.name      = "HTR from DR on F/B",
-
-	.final     = false,
-	.is_done   = check_htr,
-	.estimate  = estimate_htr_drud,
-	.ready     = check_drud,
-	.ready_msg = check_dr_msg,
-	.is_valid  = validate_singlecw_ending,
-	.moveset   = &moveset_drud,
-
-	.pre_trans = fd,
-
-	.tables    = {&pd_htr_drud},
-	.ntables   = 1,
-};
-
-/* HTR finish */
-Step
-htrfin_htr = {
-	.shortname = "htrfin",
-	.name      = "HTR finish without breaking HTR",
-
-	.final     = true,
-	.is_done   = is_solved,
-	.estimate  = estimate_htrfin_htr,
-	.ready     = check_htr,
-	.ready_msg = check_htr_msg,
-	.is_valid  = always_valid,
-	.moveset   = &moveset_htr,
-
-	.pre_trans = uf,
-
-	.tables    = {&pd_htrfin_htr},
-	.ntables   = 1,
-};
-
-Step *steps[] = {
-	&optimal_HTM, /* first is default */
-	&optimal_light_HTM,
-
-	&eofin_eo,
-	&eofbfin_eofb,
-	&eorlfin_eorl,
-	&eoudfin_eoud,
-
-	&eoany_HTM,
-	&eofb_HTM,
-	&eorl_HTM,
-	&eoud_HTM,
-
-	&coany_HTM,
-	&coud_HTM,
-	&corl_HTM,
-	&cofb_HTM,
-
-	&coany_URF,
-	&coud_URF,
-	&corl_URF,
-	&cofb_URF,
-
-	&drany_HTM,
-	&drud_HTM,
-	&drrl_HTM,
-	&drfb_HTM,
-
-	&dr_eo,
-	&dr_eofb,
-	&dr_eorl,
-	&dr_eoud,
-	&drud_eofb,
-	&drrl_eofb,
-	&drud_eorl,
-	&drfb_eorl,
-	&drfb_eoud,
-	&drrl_eoud,
-
-	&dranyfin_DR,
-	&drudfin_drud,
-	&drrlfin_drrl,
-	&drfbfin_drfb,
-
-	&htr_any,
-	&htr_drud,
-	&htr_drrl,
-	&htr_drfb,
-
-	&htrfin_htr,
-
-	&cornershtr_HTM,
-	&cornershtr_URF,
-	&corners_HTM,
-	&corners_URF,
-
-	NULL
-};
-
-/* Checkers, estimators and validators ***************************************/
-
-static bool
-check_centers(Cube cube)
-{
-	return cube.cpos == 0;
-}
-
-static bool
-check_coud_HTM(Cube cube)
-{
-	return cube.coud == 0;
-}
-
-static bool
-check_coud_URF(Cube cube)
-{
-	Cube c2, c3;
-
-	c2 = apply_move(z, cube);
-	c3 = apply_move(x, cube);
+#include "steps.h"
 
-	return cube.coud == 0 || c2.coud == 0 || c3.coud == 0;
-}
+/* TODO: change all checkers to use coordinates! */
 
-static bool
-check_corners_URF(Cube cube)
+bool
+check_centers(Cube *cube)
 {
-	Cube c;
-	Trans i;
+	int i;
 
-	for (i = 0; i < NROTATIONS; i++) {
-		c = apply_alg(rotation_alg(i), cube);
-		if (c.cp && c.coud)
-			return true;
-	}
+	for (i = 0; i < 6; i++)
+		if (cube->xp[i] != i)
+			return false;
 
-	return false;
+	return true;
 }
 
-static bool
-check_corners_HTM(Cube cube)
+bool
+check_coud_HTM(Cube *cube)
 {
-	return cube.cp == 0 && cube.coud == 0;
-}
+	int i;
 
-static bool
-check_cornershtr(Cube cube)
-{
-	return coord_cornershtr.index(cube) == 0;
-}
+	for (i = 0; i < 8; i++)
+		if (cube->co[i] != 0)
+			return false;
 
-static bool
-check_eofb(Cube cube)
-{
-	return cube.eofb == 0;
+	return true;
 }
 
-static bool
-check_drud(Cube cube)
+bool
+check_coud_URF(Cube *cube)
 {
-	return cube.eofb == 0 && cube.eorl == 0 && cube.coud == 0;
-}
+	Cube c2, c3;
 
-static bool
-check_htr(Cube cube)
-{
-	return check_drud(cube) && coord_htr_drud.index(cube) == 0;
-}
+	copy_cube(cube, &c2);
+	copy_cube(cube, &c3);
 
-static int
-estimate_eofb_HTM(DfsArg *arg)
-{
-	return ptableval(&pd_eofb_HTM, arg->cube);
-}
+	apply_move(z, &c2);
+	apply_move(x, &c3);
 
-static int
-estimate_coud_HTM(DfsArg *arg)
-{
-	return ptableval(&pd_coud_HTM, arg->cube);
+	return check_coud_HTM(cube) ||
+	       check_coud_HTM(&c2)  ||
+	       check_coud_HTM(&c3);
 }
 
-static int
-estimate_coud_URF(DfsArg *arg)
+bool
+check_cp_HTM(Cube *cube)
 {
-	/* TODO: I can improve this by checking first the orientation of
-	 * the corner in DBL and use that as a reference */
-
-	Cube c;
-
-	c = arg->cube;
-
-	int ud = estimate_coud_HTM(arg);
-	arg->cube = apply_move(z, c);
-	int rl = estimate_coud_HTM(arg);
-	arg->cube = apply_move(x, c);
-	int fb = estimate_coud_HTM(arg);
-
-	arg->cube = c;
+	int i;
 
-	return MIN(ud, MIN(rl, fb));
-}
+	for (i = 0; i < 8; i++)
+		if (cube->cp[i] != i)
+			return false;
 
-static int
-estimate_corners_HTM(DfsArg *arg)
-{
-	return ptableval(&pd_corners_HTM, arg->cube);
-}
-
-static int
-estimate_cornershtr_HTM(DfsArg *arg)
-{
-	return ptableval(&pd_cornershtr_HTM, arg->cube);
+	return true;
 }
 
-static int
-estimate_cornershtr_URF(DfsArg *arg)
+bool
+check_corners_HTM(Cube *cube)
 {
-	/* TODO: I can improve this by checking first the corner in DBL
-	 * and use that as a reference */
-
-	int ret;
-	Cube c;
-	Trans i;
-
-	c = arg->cube;
-	ret = 15;
-
-	for (i = 0; i < NROTATIONS; i++) {
-		arg->cube = apply_alg(rotation_alg(i), c);
-		ret = MIN(ret, estimate_cornershtr_HTM(arg));
-	}
-
-	arg->cube = c;
-
-	return ret;
+	return check_coud_HTM(cube) && check_cp_HTM(cube);
 }
 
-static int
-estimate_corners_URF(DfsArg *arg)
+bool
+check_corners_URF(Cube *cube)
 {
-	/* TODO: I can improve this by checking first the corner in DBL
-	 * and use that as a reference */
-
-	int ret;
 	Cube c;
 	Trans i;
 
-	c = arg->cube;
-	ret = 15;
-
 	for (i = 0; i < NROTATIONS; i++) {
-		arg->cube = apply_alg(rotation_alg(i), c);
-		ret = MIN(ret, estimate_corners_HTM(arg));
+		copy_cube(cube, &c);
+		apply_alg(rotation_alg(i), &c);
+		if (check_corners_HTM(&c))
+			return true;
 	}
 
-	arg->cube = c;
-
-	return ret;
-}
-
-static int
-estimate_drud_HTM(DfsArg *arg)
-{
-	return ptableval(&pd_drud_sym16_HTM, arg->cube);
-}
-
-static int
-estimate_drud_eofb(DfsArg *arg)
-{
-	return ptableval(&pd_drud_eofb, arg->cube);
-}
-
-static int
-estimate_dr_eofb(DfsArg *arg)
-{
-	int r1, r2;
-
-	r1 = ptableval(&pd_drud_eofb, arg->cube);
-	r2 = ptableval(&pd_drud_eofb, apply_trans(rf, arg->cube));
-
-	return MIN(r1, r2);
-}
-
-static int
-estimate_drudfin_drud(DfsArg *arg)
-{
-	int val = ptableval(&pd_drudfin_noE_sym16_drud, arg->cube);
-
-	if (val != 0)
-		return val;
-
-	return arg->cube.epose % 24 == 0 ? 0 : 1;
-}
-
-static int
-estimate_htr_drud(DfsArg *arg)
-{
-	return ptableval(&pd_htr_drud, arg->cube);
-}
-
-static int
-estimate_htrfin_htr(DfsArg *arg)
-{
-	return ptableval(&pd_htrfin_htr, arg->cube);
+	return false;
 }
 
-static int
-estimate_nxopt31_HTM(DfsArg *arg)
+bool
+check_cornershtr(Cube *cube)
 {
-	return estimate_nxoptlike(arg, &pd_nxopt31_HTM);
+	/* TODO (use coord) */
+	return true;
 }
 
-/* TODO: also use generic procedure for this */
-static int
-estimate_light_HTM(DfsArg *arg)
+bool
+check_eofb(Cube *cube)
 {
-	int target, ret;
-	Cube aux;
-
-	static const uint64_t udmask = (1<<U) | (1<<U2) | (1<<U3) |
-				       (1<<D) | (1<<D2) | (1<<D3);
-	static const uint64_t rlmask = (1<<R) | (1<<R2) | (1<<R3) |
-				       (1<<L) | (1<<L2) | (1<<L3);
-	static const uint64_t fbmask = (1<<F) | (1<<F2) | (1<<F3) |
-				       (1<<B) | (1<<B2) | (1<<B3);
-	static const uint64_t htmask = (1<<U2) | (1<<D2) |
-				       (1<<R2) | (1<<L2) |
-				       (1<<F2) | (1<<B2);
-
-	ret              = -1;
-	target           = arg->d - arg->current_alg->len;
-	arg->inverse     = (Cube){0};
-	arg->badmovesinv = 0;
-	arg->badmoves    = 0;
-
-	/* Corners */
-	arg->ed->corners = ptableval(&pd_corners_HTM, arg->cube);
-	UPDATECHECKSTOP(ret, arg->ed->corners, target);
-
-	/* Normal probing */
-	arg->ed->normal_ud = ptableval(&pd_drud_sym16_HTM, arg->cube);
-	UPDATECHECKSTOP(ret, arg->ed->normal_ud, target);
-	aux = apply_trans(fd, arg->cube);
-	arg->ed->normal_fb = ptableval(&pd_drud_sym16_HTM, aux);
-	UPDATECHECKSTOP(ret, arg->ed->normal_fb, target);
-	aux = apply_trans(rf, arg->cube);
-	arg->ed->normal_rl = ptableval(&pd_drud_sym16_HTM, aux);
-	UPDATECHECKSTOP(ret, arg->ed->normal_rl, target);
-
-	/* If ret == 0, it's solved (corners + triple slice solved) */
-	if (ret == 0)
-		return is_solved(arg->cube) ? 0 : 1;
-
-	/* Michel de Bondt's trick*/
-	if (arg->ed->normal_ud == arg->ed->normal_fb &&
-	    arg->ed->normal_fb == arg->ed->normal_rl) {
-		UPDATECHECKSTOP(ret, arg->ed->normal_ud + 1, target);
-	}
-
-	/* Inverse probing */
-	if (!((1<<arg->last1) & htmask)) {
-		aux = arg->inverse = inverse_cube(arg->cube);
-		if (!((1<<arg->last1) & udmask) || (arg->ed->inverse_ud==-1)) {
-			arg->ed->inverse_ud =
-			    ptableval(&pd_drud_sym16_HTM, aux);
-		}
-		UPDATECHECKSTOP(ret, arg->ed->inverse_ud, target);
-		if (!((1<<arg->last1) & fbmask) || (arg->ed->inverse_fb==-1)) {
-			aux = apply_trans(fd, arg->inverse);
-			arg->ed->inverse_fb =
-			    ptableval(&pd_drud_sym16_HTM, aux);
-		}
-		UPDATECHECKSTOP(ret, arg->ed->inverse_fb, target);
-		if (!((1<<arg->last1) & rlmask) || (arg->ed->inverse_rl==-1)) {
-			aux = apply_trans(rf, arg->inverse);
-			arg->ed->inverse_rl =
-			    ptableval(&pd_drud_sym16_HTM, aux);
-		}
-		UPDATECHECKSTOP(ret, arg->ed->inverse_rl, target);
-	} else {
-		UPDATECHECKSTOP(ret, arg->ed->inverse_ud, target);
-		UPDATECHECKSTOP(ret, arg->ed->inverse_fb, target);
-		UPDATECHECKSTOP(ret, arg->ed->inverse_rl, target);
-	}
-
-	/* Michel de Bondt's trick*/
-	if (arg->ed->inverse_ud == arg->ed->inverse_fb &&
-	    arg->ed->inverse_fb == arg->ed->inverse_rl) {
-		UPDATECHECKSTOP(ret, arg->ed->inverse_ud + 1, target);
-	}
-
-	/* nxopt trick + half turn trick */
-	if (arg->ed->normal_ud == target)
-		arg->badmovesinv |= udmask | htmask;
-	if (arg->ed->normal_fb == target)
-		arg->badmovesinv |= fbmask | htmask;
-	if (arg->ed->normal_rl == target)
-		arg->badmovesinv |= rlmask | htmask;
-
-	if (arg->ed->inverse_ud == target)
-		arg->badmoves |= udmask | htmask;
-	if (arg->ed->inverse_fb == target)
-		arg->badmoves |= fbmask | htmask;
-	if (arg->ed->inverse_rl == target)
-		arg->badmoves |= rlmask | htmask;
-
-	return arg->ed->oldret = ret;
+	/* TODO (use coord) */
+	return true;
 }
 
-static int
-estimate_nxoptlike(DfsArg *arg, PruneData *pd)
+bool
+check_drud(Cube *cube)
 {
-	int target, ret;
-	Cube aux;
-
-	static const uint64_t udmask = (1<<U) | (1<<U2) | (1<<U3) |
-				       (1<<D) | (1<<D2) | (1<<D3);
-	static const uint64_t rlmask = (1<<R) | (1<<R2) | (1<<R3) |
-				       (1<<L) | (1<<L2) | (1<<L3);
-	static const uint64_t fbmask = (1<<F) | (1<<F2) | (1<<F3) |
-				       (1<<B) | (1<<B2) | (1<<B3);
-
-	ret              = -1;
-	target           = arg->d - arg->current_alg->len;
-	arg->inverse     = (Cube){0};
-	arg->badmovesinv = 0;
-	arg->badmoves    = 0;
-
-	/* Corners */
-	arg->ed->corners = ptableval(&pd_corners_HTM, arg->cube);
-	UPDATECHECKSTOP(ret, arg->ed->corners, target);
-
-	/* Normal probing */
-	arg->ed->normal_ud = ptableval(pd, arg->cube);
-	UPDATECHECKSTOP(ret, arg->ed->normal_ud, target);
-	aux = apply_trans(fd, arg->cube);
-	arg->ed->normal_fb = ptableval(pd, aux);
-	UPDATECHECKSTOP(ret, arg->ed->normal_fb, target);
-	aux = apply_trans(rf, arg->cube);
-	arg->ed->normal_rl = ptableval(pd, aux);
-	UPDATECHECKSTOP(ret, arg->ed->normal_rl, target);
-
-	if (ret == 0)
-		return arg->step->is_done(arg->cube) ? 0 : 1;
-
-	/* Michel de Bondt's trick*/
-	if (arg->ed->normal_ud == arg->ed->normal_fb &&
-	    arg->ed->normal_fb == arg->ed->normal_rl) {
-		UPDATECHECKSTOP(ret, arg->ed->normal_ud + 1, target);
-	}
-
-	/* Inverse probing */
-	aux = arg->inverse = inverse_cube(arg->cube);
-	if (!((1<<arg->last1) & udmask) || (arg->ed->inverse_ud == -1)) {
-		arg->ed->inverse_ud = ptableval(pd, aux);
-	}
-	UPDATECHECKSTOP(ret, arg->ed->inverse_ud, target);
-	if (!((1<<arg->last1) & fbmask) || (arg->ed->inverse_fb == -1)) {
-		aux = apply_trans(fd, arg->inverse);
-		arg->ed->inverse_fb = ptableval(pd, aux);
-	}
-	UPDATECHECKSTOP(ret, arg->ed->inverse_fb, target);
-	if (!((1<<arg->last1) & rlmask) || (arg->ed->inverse_rl == -1)) {
-		aux = apply_trans(rf, arg->inverse);
-		arg->ed->inverse_rl = ptableval(pd, aux);
-	}
-	UPDATECHECKSTOP(ret, arg->ed->inverse_rl, target);
-
-	/* Michel de Bondt's trick*/
-	if (arg->ed->inverse_ud == arg->ed->inverse_fb &&
-	    arg->ed->inverse_fb == arg->ed->inverse_rl) {
-		UPDATECHECKSTOP(ret, arg->ed->inverse_ud + 1, target);
-	}
-
-	/* nxopt trick */
-	if (arg->ed->normal_ud == target)
-		arg->badmovesinv |= udmask;
-	if (arg->ed->normal_fb == target)
-		arg->badmovesinv |= fbmask;
-	if (arg->ed->normal_rl == target)
-		arg->badmovesinv |= rlmask;
-
-	if (arg->ed->inverse_ud == target)
-		arg->badmoves |= udmask;
-	if (arg->ed->inverse_fb == target)
-		arg->badmoves |= fbmask;
-	if (arg->ed->inverse_rl == target)
-		arg->badmoves |= rlmask;
-
-	return arg->ed->oldret = ret;
+	/* TODO (use coord) */
+	return true;
 }
 
-
-static bool
-always_valid(Alg *alg)
+bool
+check_htr(Cube *cube)
 {
+	/* TODO (check_drud(cube) and coord_htr_drud == 0) */
 	return true;
 }
 
-static bool
+bool
 validate_singlecw_ending(Alg *alg)
 {
 	int i;
@@ -1389,93 +129,93 @@ validate_singlecw_ending(Alg *alg)
 	return nor && inv;
 }
 
-/* Pre-transformation detectors **********************************************/
+/* Public functions **********************************************************/
 
-static int
-detect_pretrans_eofb(Cube cube, Trans *ret)
+void
+compute_ind(StepAlt *a, Cube *cube, Movable *ind)
 {
-	int i, n;
-	static Trans tt[3] = {uf, ur, fd};
+	int i;
+	Cube mvd;
+	Trans t, tt;
 
-	for (i = 0, n = 0; i < 3; i++)
-		if (check_eofb(apply_trans(tt[i], cube)))
-			ret[n++] = tt[i];
+	for (i = 0; i < a->n_coord; i++) {
+		t = a->coord_trans[i];
+		copy_cube(cube, &mvd);
+		apply_trans(t, &mvd);
 
-	return n;
+		ind[i].val = index_coord(a->coord[i], &mvd, &tt);
+		ind[i].t = transform_trans(tt, t);
+	}
 }
 
-static int
-detect_pretrans_drud(Cube cube, Trans *ret)
+int
+estimate_stepalt(StepAlt *a, Movable *ind, int goal)
 {
-	int i, n;
-	static Trans tt[3] = {uf, fr, rd};
+	int i, ret, est[a->n_coord];
 
-	for (i = 0, n = 0; i < 3; i++)
-		if (check_drud(apply_trans(tt[i], cube)))
-			ret[n++] = tt[i];
+	for (i = 0; i < a->n_coord; i++) {
+		est[i] = ptableval(a->pd[i], ind[i].val);
+		if (est[i] == a->pd[i]->base && a->compact_pd[i])
+			est[i] = ptableval(a->fallback_pd[i],
+			    ind[i].val/a->fbmod[i]);
+		if (ind[i].val != 0 && est[i] == 0) /* est == 0 iff solved */
+			est[i] = 1;
+/*
+TODO: remove this debug code
+printf("%d: est=%d | ", i, est[i]);
+*/
 
-	return n;
-}
+		if (est[i] > goal)
+			return est[i];
+	}
 
-static int
-detect_pretrans_void_3axis(Cube cube, Trans *ret)
-{
-	ret[0] = uf;
-	ret[1] = fr;
-	ret[2] = rd;
+	for (i = 0; i < a->n_dbtrick; i++)
+		if (est[a->dbtrick[i][0]] > 0 &&
+		    est[a->dbtrick[i][0]] == est[a->dbtrick[i][1]] &&
+		    est[a->dbtrick[i][0]] == est[a->dbtrick[i][2]])
+			est[a->dbtrick[i][0]] += 1;
 
-	return 3;
-}
+	for (i = 0, ret = -1; i < a->n_coord; i++)
+		ret = MAX(ret, est[i]);
 
-/* Public functions **********************************************************/
+/*
+TODO: remove this debug code
+printf("Final estimate: %d\n", ret);
+*/
 
-void
-copy_estimatedata(EstimateData *src, EstimateData *dst)
-{
-	dst->corners    = src->corners;
-	dst->normal_ud  = src->normal_ud;
-	dst->normal_fb  = src->normal_fb;
-	dst->normal_rl  = src->normal_rl;
-	dst->inverse_ud = src->inverse_ud;
-	dst->inverse_fb = src->inverse_fb;
-	dst->inverse_rl = src->inverse_rl;
-	dst->oldret     = src->oldret;
+	return ret;
 }
 
 void
-invert_estimatedata(EstimateData *ed)
+prepare_step(Step *step, SolveOptions *opts)
 {
-	swap(&(ed->normal_ud), &(ed->inverse_ud));
-	swap(&(ed->normal_fb), &(ed->inverse_fb));
-	swap(&(ed->normal_rl), &(ed->inverse_rl));
-}
+	int i, j;
+	PDGenData pdg;
+	StepAlt *a;
 
-void
-reset_estimatedata(EstimateData *ed)
-{
-	ed->corners    = -1;
-	ed->normal_ud  = -1;
-	ed->normal_fb  = -1;
-	ed->normal_rl  = -1;
-	ed->inverse_ud = -1;
-	ed->inverse_fb = -1;
-	ed->inverse_rl = -1;
-	ed->oldret     = -1;
-}
+	for (i = 0; step->alt[i] != NULL; i++) {
+		a = step->alt[i];
+		init_moveset(a->moveset);
+		pdg.moveset = a->moveset;
+		for (j = 0; j < a->n_coord; j++) {
+			gen_coord(a->coord[j]);
 
-void
-prepare_step(Step *step, SolveOptions *opts)
-{
-	int i;
+			pdg.coord   = a->coord[j];
+			pdg.compact = a->compact_pd[j];
+			pdg.pd      = NULL;
 
-	if (step->final && opts->can_niss) {
-		opts->can_niss = false;
-		fprintf(stderr, "Step is final, NISS not used (-n ignored)\n");
-	}
+			a->pd[j] = genptable(&pdg, opts->nthreads);
+
+			if (a->compact_pd[j]) {
+				gen_coord(a->fallback_coord[j]);
 
-	for (i = 0; i < step->ntables; i++) {
-		genptable(step->tables[i], opts->nthreads);
-		if (step->tables[i]->compact)
-			genptable(step->tables[i]->fallback, opts->nthreads);
+				pdg.coord   = a->fallback_coord[j];
+				pdg.compact = false;
+				pdg.pd      = NULL;
+
+				a->fallback_pd[j] =
+				    genptable(&pdg, opts->nthreads);
+			}
+		}
 	}
 }
diff --git a/src/steps.h b/src/steps.h
@@ -3,15 +3,275 @@
 
 #include "pruning.h"
 
-extern Step *           steps[];
+bool                    check_centers(Cube *cube);
+bool                    check_coud_HTM(Cube *cube);
+bool                    check_coud_URF(Cube *cube);
+bool                    check_cp_HTM(Cube *cube);
+bool                    check_corners_HTM(Cube *cube);
+bool                    check_corners_URF(Cube *cube);
+bool                    check_cornershtr(Cube *cube);
+bool                    check_eofb(Cube *cube);
+bool                    check_drud(Cube *cube);
+bool                    check_htr(Cube *cube);
+void                    compute_ind(StepAlt *a, Cube *cube, Movable *ind);
+int                     estimate_stepalt(StepAlt *a, Movable *ind, int goal);
+void                    prepare_step(Step *step, SolveOptions *opts);
+bool                    always_valid(Alg *alg);
+bool                    validate_singlecw_ending(Alg *alg);
 
-/* Two steps used directly by two-phase solver */
-extern Step             drany_HTM;
-extern Step             dranyfin_DR;
+#ifndef STEPS_C
 
-void                    copy_estimatedata(EstimateData *s, EstimateData *d);
-void                    invert_estimatedata(EstimateData *ed);
-void                    reset_estimatedata(EstimateData *ed);
-void                    prepare_step(Step *step, SolveOptions *opts);
+extern char check_centers_msg[100];
+extern char check_eo_msg[100];
+extern char check_dr_msg[100];
+extern char check_htr_msg[100];
+extern char check_drany_msg[100];
+
+extern StepAlt sa_nxopt31_HTM;
+extern StepAlt sa_eofb_HTM;
+extern StepAlt sa_drud_HTM;
+extern StepAlt sa_drfin_drud;
+
+extern Step optimal_HTM;
+extern Step eoany_HTM;
+extern Step eofb_HTM;
+extern Step eorl_HTM;
+extern Step eoud_HTM;
+extern Step drany_HTM;
+extern Step drud_HTM;
+extern Step drrl_HTM;
+extern Step drfb_HTM;
+extern Step dranyfin_DR;
+extern Step drudfin_drud;
+extern Step drrlfin_drrl;
+extern Step drfbfin_drfb;
+
+extern Step *steps[];
+
+#else
+
+char check_centers_msg[100] = "cube must be oriented (centers solved)";
+char check_eo_msg[100]      = "EO must be solved on given axis";
+char check_dr_msg[100]      = "DR must be solved on given axis";
+char check_htr_msg[100]     = "HTR must be solved";
+char check_drany_msg[100]   = "DR must be solved on at least one axis";
+
+/* Optimal solvers *******************/
+/* TODO: build options for smaller optimal solvers */
+
+StepAlt
+sa_nxopt31_HTM = {
+	.ready          = check_centers,
+	.final          = true,
+	.moveset        = &moveset_HTM,
+	.n_coord        = 6,
+	.coord          = {&coord_nxopt31, &coord_nxopt31, &coord_nxopt31,
+			   &coord_eposepe, &coord_eposepe, &coord_eposepe},
+			  /* TODO: use khuge as fallback? */
+	.coord_trans    = {uf, rd, bl, uf, rd, bl},
+	.compact_pd     = {true, true, true, false, false, false},
+	.fallback_coord = {&coord_drud_sym16, &coord_drud_sym16,
+	                   &coord_drud_sym16},
+	.fbmod          = {BINOM8ON4, BINOM8ON4, BINOM8ON4},
+	.n_dbtrick      = 1, /* TODO: change to 2 when khuge */
+	.dbtrick        = {{0, 1, 2}},
+	.is_valid       = NULL,
+};
+Step
+optimal_HTM = {
+	.shortname = "optimal",
+	.name      = "Optimal solve (in HTM)",
+	.alt       = {&sa_nxopt31_HTM, NULL},
+	.t         = {uf},
+	.ready_msg = check_centers_msg,
+};
+
+/* Optimal after EO ******************/
+/* TODO: eofin_eo (generic), eofbfin_eofb, eorlfin_eorl, eoudfin_eoud */
+
+/* EO steps **************************/
+/* TODO: eoany_HTM (generic), eofb_HTM, eorl_HTM, eoud_HTM */
+
+StepAlt
+sa_eofb_HTM = {
+	.ready          = check_centers,
+	.final          = false,
+	.moveset        = &moveset_HTM,
+	.n_coord        = 1,
+	.coord          = {&coord_eofb},
+	.coord_trans    = {uf},
+	.compact_pd     = {false},
+	.n_dbtrick      = 0,
+	.is_valid       = validate_singlecw_ending,
+};
+Step
+eoany_HTM = {
+	.shortname = "eo",
+	.name      = "EO on any axis",
+	.alt       = {&sa_eofb_HTM, &sa_eofb_HTM, &sa_eofb_HTM, NULL},
+	.t         = {uf, ur, fd},
+	.ready_msg = check_centers_msg,
+};
+Step
+eofb_HTM = {
+	.shortname = "eofb",
+	.name      = "EO on F/B",
+	.alt       = {&sa_eofb_HTM, NULL},
+	.t         = {uf},
+	.ready_msg = check_centers_msg,
+};
+Step
+eorl_HTM = {
+	.shortname = "eorl",
+	.name      = "EO on R/L",
+	.alt       = {&sa_eofb_HTM, NULL},
+	.t         = {ur},
+	.ready_msg = check_centers_msg,
+};
+Step
+eoud_HTM = {
+	.shortname = "eoud",
+	.name      = "EO on U/D",
+	.alt       = {&sa_eofb_HTM, NULL},
+	.t         = {fd},
+	.ready_msg = check_centers_msg,
+};
+
+/* CO steps **************************/
+/* TODO: coany_HTM (generic), cofb_HTM, corl_HTM, coud_HTM */
+/* TODO: coany_URF (generic), cofb_URF, corl_URF, coud_URF */
+
+/* Misc corner steps *****************/
+/* TODO: cornershtr_HTM, cornershtr_URF, corners_HTM, corners_URF */
+/* TODO (new): corners_drud */
+
+/* DR steps **************************/
+/* TODO: dr_eo (generic) */
+/* TODO: dr_eofb (generic), dr_eorl (generic), dr_eoud (generic) */
+/* TODO: drud_eofb, drrl_eofb, drud_eorl, drfb_eorl, drrl_eoud, drfb_eoud */
+
+StepAlt
+sa_drud_HTM = {
+	.ready          = check_centers,
+	.final          = false,
+	.moveset        = &moveset_HTM,
+	.n_coord        = 1,
+	.coord          = {&coord_drud_sym16},
+	.coord_trans    = {uf},
+	.compact_pd     = {false}, /* TODO: maybe compactify */
+	.n_dbtrick      = 0,
+	.is_valid       = validate_singlecw_ending,
+};
+Step
+drany_HTM = {
+	.shortname = "dr",
+	.name      = "DR on any axis",
+	.alt       = {&sa_drud_HTM, &sa_drud_HTM, &sa_drud_HTM, NULL},
+	.t         = {uf, rf, fd},
+	.ready_msg = check_centers_msg,
+};
+Step
+drud_HTM = {
+	.shortname = "drud",
+	.name      = "DR on U/D",
+	.alt       = {&sa_drud_HTM, NULL},
+	.t         = {uf},
+	.ready_msg = check_centers_msg,
+};
+Step
+drrl_HTM = {
+	.shortname = "drrl",
+	.name      = "DR on R/L",
+	.alt       = {&sa_drud_HTM, NULL},
+	.t         = {rf},
+	.ready_msg = check_centers_msg,
+};
+Step
+drfb_HTM = {
+	.shortname = "drfb",
+	.name      = "DR on F/B",
+	.alt       = {&sa_drud_HTM, NULL},
+	.t         = {fd},
+	.ready_msg = check_centers_msg,
+};
+
+/* DR finish steps */
+StepAlt
+sa_drfin_drud = {
+	.ready          = check_drud,
+	.final          = true,
+	.moveset        = &moveset_drud,
+	.n_coord        = 1,
+	.coord          = {&coord_drudfin_noE_sym16}, /* TODO: maybe no noE */
+	.coord_trans    = {uf},
+	.compact_pd     = {false}, /* TODO: maybe compactify */
+	.n_dbtrick      = 0,
+	.is_valid       = NULL,
+};
+Step
+dranyfin_DR = {
+	.shortname = "drfin",
+	.name      = "DR finish on any axis without breaking DR",
+	.alt       = {&sa_drfin_drud, &sa_drfin_drud, &sa_drfin_drud, NULL},
+	.t         = {uf, rf, fd},
+	.ready_msg = check_dr_msg,
+};
+Step
+drudfin_drud = {
+	.shortname = "drudfin",
+	.name      = "DR finis on U/D without breaking DR",
+	.alt       = {&sa_drfin_drud, NULL},
+	.t         = {uf},
+	.ready_msg = check_dr_msg,
+};
+Step
+drrlfin_drrl = {
+	.shortname = "drrlfin",
+	.name      = "DR finish on R/L without breaking DR",
+	.alt       = {&sa_drfin_drud, NULL},
+	.t         = {rf},
+	.ready_msg = check_dr_msg,
+};
+Step
+drfbfin_drfb = {
+	.shortname = "drfbfin",
+	.name      = "DR finish on F/B without breaking DR",
+	.alt       = {&sa_drfin_drud, NULL},
+	.t         = {fd},
+	.ready_msg = check_dr_msg,
+};
+
+/* HTR from DR */
+/* TODO: htr_any (generic), htr_drud, htr_drrl, htr_drfb */
+
+/* HTR finish */
+/* TODO: htrfin_htr */
+
+Step *steps[] = {
+	&optimal_HTM, /* first is default */
+
+	&eoany_HTM, &eofb_HTM, &eorl_HTM, &eoud_HTM,
+	&drany_HTM, &drud_HTM, &drrl_HTM, &drfb_HTM,
+	&dranyfin_DR, &drudfin_drud, &drrlfin_drrl, &drfbfin_drfb,
+
+/* TODO:
+	&optimal_light_HTM,
+
+	&eofin_eo, &eofbfin_eofb, &eorlfin_eorl, &eoudfin_eoud,
+	&coany_HTM, &coud_HTM, &corl_HTM, &cofb_HTM,
+	&coany_URF, &coud_URF, &corl_URF, &cofb_URF,
+	&dr_eo, &dr_eofb, &dr_eorl, &dr_eoud,
+	&drud_eofb, &drrl_eofb,
+	&drud_eorl, &drfb_eorl,
+	&drfb_eoud, &drrl_eoud,
+	&htr_any, &htr_drud, &htr_drrl, &htr_drfb,
+	&htrfin_htr,
+	&cornershtr_HTM, &cornershtr_URF, &corners_HTM, &corners_URF,
+	NULL
+*/
+
+};
+
+#endif
 
 #endif
diff --git a/src/symcoord.c b/src/symcoord.c
@@ -1,687 +0,0 @@
-#include "symcoord.h"
-
-/* These constants have been computed generating the respective SymData */
-#define CLASSES_CP_16        2768
-#define CLASSES_EOFBEPOS_16  64430
-
-static uint64_t    index_cp_sym16(Cube cube);
-static uint64_t    index_eofbepos_sym16(Cube cube);
-static uint64_t    index_drud_sym16(Cube cube);
-static uint64_t    index_drudfin_noE_sym16(Cube cube);
-static uint64_t    index_nxopt31(Cube cube);
-
-static uint64_t    move_cp_sym16(Move m, uint64_t ind);
-static uint64_t    move_eofbepos_sym16(Move m, uint64_t ind);
-static uint64_t    move_drud_sym16(Move m, uint64_t ind);
-static uint64_t    move_drudfin_noE_sym16(Move m, uint64_t ind);
-static uint64_t    move_nxopt31(Move m, uint64_t ind);
-
-static int         tfind_from_mask(uint64_t mask, Trans *ret);
-static int         tfind_drud_sym16(uint64_t ind, Trans *ret);
-static int         tfind_drudfin_noE_sym16(uint64_t ind, Trans *ret);
-static int         tfind_nxopt31(uint64_t ind, Trans *ret);
-
-static uint64_t    transform_cp(Trans t, uint64_t ind);
-static uint64_t    transform_eofbepos(Trans t, uint64_t ind);
-static uint64_t    transform_drud_sym16(Trans t, uint64_t ind);
-static uint64_t    transform_drudfin_noE_sym16(Trans t, uint64_t ind);
-static uint64_t    transform_nxopt31(Trans t, uint64_t ind);
-
-static void        gensym(SymData *sd);
-static void        init_symc_moves();
-static void        init_symc_trans();
-static bool        read_symdata_file(SymData *sd);
-static bool        read_symc_moves_file();
-static bool        read_symc_trans_file();
-static bool        write_symdata_file(SymData *sd);
-static bool        write_symc_moves_file();
-static bool        write_symc_trans_file();
-
-/* Some tables ***************************************************************/
-
-static uint64_t    move_cp_16[NMOVES][CLASSES_CP_16];
-static uint64_t    move_eofbepos_16[NMOVES][CLASSES_EOFBEPOS_16];
-
-static int         trans_eofbepos[NTRANS][POW2TO11*BINOM12ON4];
-static int         trans_epud[NTRANS][FACTORIAL8];
-static int         trans_cpud_separate[NTRANS][BINOM8ON4];
-
-static Trans       ttrep_move_cp_16[NMOVES][CLASSES_CP_16];
-static Trans       ttrep_move_eofbepos_16[NMOVES][CLASSES_EOFBEPOS_16];
-
-
-/* Transformation groups and symmetry data ***********************************/
-
-static Trans
-trans_group_udfix[16] = {
-	uf, ur, ub, ul,
-	df, dr, db, dl,
-	uf_mirror, ur_mirror, ub_mirror, ul_mirror,
-	df_mirror, dr_mirror, db_mirror, dl_mirror,
-};
-
-static SymData
-sd_cp_16 = {
-	.filename  = "sd_cp_16_new",
-	.coord     = &coord_cp,
-	.sym_coord = &coord_cp_sym16,
-	.ntrans    = 16,
-	.trans     = trans_group_udfix,
-	.transform = transform_cp,
-};
-
-static SymData
-sd_eofbepos_16 = {
-	.filename  = "sd_eofbepos_16_new",
-	.coord     = &coord_eofbepos,
-	.sym_coord = &coord_eofbepos_sym16,
-	.ntrans    = 16,
-	.trans     = trans_group_udfix,
-	.transform = transform_eofbepos,
-};
-
-SymData * all_sd[] = {
-	&sd_cp_16,
-	&sd_eofbepos_16,
-	NULL
-};
-
-
-/* Coordinates and their implementation **************************************/
-
-Coordinate
-coord_eofbepos_sym16 = {
-	.index     = index_eofbepos_sym16,
-	.move      = move_eofbepos_sym16,
-};
-
-Coordinate
-coord_cp_sym16 = {
-	.index     = index_cp_sym16,
-	.move      = move_cp_sym16,
-};
-
-Coordinate
-coord_drud_sym16 = {
-	.index     = index_drud_sym16,
-	.move      = move_drud_sym16,
-	.max       = POW3TO7 * CLASSES_EOFBEPOS_16,
-	.base      = &coord_eofbepos_sym16,
-	.transform = transform_drud_sym16,
-	.tfind     = tfind_drud_sym16,
-};
-
-Coordinate
-coord_drudfin_noE_sym16 = {
-	.index     = index_drudfin_noE_sym16,
-	.move      = move_drudfin_noE_sym16,
-	.max       = FACTORIAL8 * CLASSES_CP_16,
-	.base      = &coord_cp_sym16,
-	.transform = transform_drudfin_noE_sym16,
-	.tfind     = tfind_drudfin_noE_sym16,
-};
-
-Coordinate
-coord_nxopt31 = {
-	.index     = index_nxopt31,
-	.move      = move_nxopt31,
-	.max       = POW3TO7 * BINOM8ON4 * CLASSES_EOFBEPOS_16,
-	.base      = &coord_eofbepos_sym16,
-	.transform = transform_nxopt31,
-	.tfind     = tfind_nxopt31,
-};
-
-/* Functions *****************************************************************/
-
-static uint64_t
-index_cp_sym16(Cube cube)
-{
-	return sd_cp_16.class[coord_cp.index(cube)];
-}
-
-static uint64_t
-index_drud_sym16(Cube cube)
-{
-	Trans t;
-
-	t = sd_eofbepos_16.transtorep[coord_eofbepos.index(cube)];
-
-	return index_eofbepos_sym16(cube) * POW3TO7 + co_ttable[t][cube.coud];
-}
-
-static uint64_t
-index_drudfin_noE_sym16(Cube cube)
-{
-	Trans t;
-	Cube c;
-
-	t = sd_cp_16.transtorep[coord_cp.index(cube)];
-	c = apply_trans(t, cube);
-
-	/* TODO: add transform to coord_epud to make this faster */
-	return index_cp_sym16(c) * FACTORIAL8 + coord_epud.index(c);
-}
-
-static uint64_t
-index_eofbepos_sym16(Cube cube)
-{
-	return sd_eofbepos_16.class[coord_eofbepos.index(cube)];
-}
-
-static uint64_t
-index_nxopt31(Cube cube)
-{
-	Trans t;
-	uint64_t a;
-	int coud, cp;
-	
-	t = sd_eofbepos_16.transtorep[coord_eofbepos.index(cube)];
-	coud = co_ttable[t][cube.coud];
-	cp   = cp_ttable[t][cube.cp];
-	a = (index_eofbepos_sym16(cube)*POW3TO7) + coud;
-
-	return a * BINOM8ON4 + coord_cpud_separate.index((Cube){.cp = cp});
-}
-
-static uint64_t
-move_cp_sym16(Move m, uint64_t ind)
-{
-	return move_cp_16[m][ind];
-}
-
-static uint64_t
-move_eofbepos_sym16(Move m, uint64_t ind)
-{
-	return move_eofbepos_16[m][ind];
-}
-
-static uint64_t
-move_drud_sym16(Move m, uint64_t ind)
-{
-	uint64_t coud, eofbepos;
-	Trans ttr;
-
-	eofbepos = move_eofbepos_16[m][ind / POW3TO7];
-	ttr = ttrep_move_eofbepos_16[m][ind / POW3TO7];
-	coud = coud_mtable[m][ind % POW3TO7];
-	coud = co_ttable[ttr][coud]; /* Source is always coud */
-
-	return eofbepos * POW3TO7 + coud;
-}
-
-static uint64_t
-move_drudfin_noE_sym16(Move m, uint64_t ind)
-{
-	uint64_t cp, epud;
-	Trans ttr;
-
-	cp = move_cp_16[m][ind / FACTORIAL8];
-	ttr = ttrep_move_cp_16[m][ind / FACTORIAL8];
-	epud = coord_epud.move(m, ind % FACTORIAL8);
-	epud = trans_epud[ttr][epud];
-
-	return cp * FACTORIAL8 + epud;
-}
-
-static uint64_t
-move_nxopt31(Move m, uint64_t ind)
-{
-	uint64_t eofbepos, cpsep, coud;
-	Trans ttr;
-
-	eofbepos = ind / (POW3TO7 * BINOM8ON4);
-	coud = (ind / BINOM8ON4) % POW3TO7;
-	cpsep = ind % BINOM8ON4;
-
-	ttr = ttrep_move_eofbepos_16[m][eofbepos];
-	eofbepos = move_eofbepos_16[m][eofbepos];
-	coud = coud_mtable[m][coud];
-	coud = co_ttable[ttr][coud]; /* Source is always coud */
-	cpsep = coord_cpud_separate.move(m, cpsep);
-	cpsep = trans_cpud_separate[ttr][cpsep];
-
-	return (eofbepos * POW3TO7 + coud) * BINOM8ON4 + cpsep;
-}
-
-static uint64_t
-transform_cp(Trans t, uint64_t ind)
-{
-	return cp_ttable[t][ind];
-}
-
-static uint64_t
-transform_eofbepos(Trans t, uint64_t ind)
-{
-	return trans_eofbepos[t][ind];
-}
-
-static uint64_t
-transform_drud_sym16(Trans t, uint64_t ind)
-{
-	uint64_t coud, eofbepos;
-
-	eofbepos = ind / POW3TO7; /* Assum trans fixes eofbepos */
-	coud = co_ttable[t][ind % POW3TO7]; /* Source is always coud */
-
-	return eofbepos * POW3TO7 + coud;
-}
-
-static uint64_t
-transform_drudfin_noE_sym16(Trans t, uint64_t ind)
-{
-	uint64_t cp, epud;
-
-	cp = ind / FACTORIAL8; /* Assume trans fixes cp */
-	epud = trans_epud[t][ind % FACTORIAL8];
-
-	return cp * FACTORIAL8 + epud;
-}
-
-static uint64_t
-transform_nxopt31(Trans t, uint64_t ind)
-{
-	uint64_t eofbepos, cpsep, coud;
-
-	eofbepos = ind / (POW3TO7 * BINOM8ON4);
-	coud = (ind / BINOM8ON4) % POW3TO7;
-	cpsep = ind % BINOM8ON4;
-
-	coud = co_ttable[t][coud]; /* Source is always coud */
-	cpsep = trans_cpud_separate[t][cpsep];
-
-	return (eofbepos * POW3TO7 + coud) * BINOM8ON4 + cpsep;
-}
-
-static int
-tfind_from_mask(uint64_t mask, Trans *ret)
-{
-	Trans t;
-	int i = 0;
-
-	for (t = uf; t < NTRANS; t++)
-		if (((uint64_t)1 << t) & mask)
-			ret[i++] = t;
-
-	return i;
-}
-
-static int
-tfind_drud_sym16(uint64_t ind, Trans *ret)
-{
-	uint64_t mask = sd_eofbepos_16.selfsim[ind / POW3TO7];
-
-	return tfind_from_mask(mask, ret);
-}
-
-static int
-tfind_drudfin_noE_sym16(uint64_t ind, Trans *ret)
-{
-	uint64_t mask = sd_cp_16.selfsim[ind / FACTORIAL8];
-
-	return tfind_from_mask(mask, ret);
-}
-
-static int
-tfind_nxopt31(uint64_t ind, Trans *ret)
-{
-	uint64_t mask = sd_eofbepos_16.selfsim[ind / (POW3TO7 * BINOM8ON4)];
-
-	return tfind_from_mask(mask, ret);
-}
-
-/* Other functions ***********************************************************/
-
-void
-free_sd(SymData *sd)
-{
-	if (sd->generated) {
-		free(sd->class);
-		free(sd->unsym);
-		free(sd->transtorep);
-	}
-
-	sd->generated = false;
-}
-
-static void
-gensym(SymData *sd)
-{
-	uint64_t i, in, nreps = 0;
-	Trans t;
-	int j;
-
-	if (sd->generated)
-		return;
-
-	sd->class      = malloc(sd->coord->max * sizeof(uint64_t));
-	sd->unsym      = malloc(sd->coord->max * sizeof(uint64_t));
-	sd->transtorep = malloc(sd->coord->max * sizeof(Trans));
-	sd->selfsim    = malloc(sd->coord->max * sizeof(uint64_t));
-
-	if (read_symdata_file(sd)) {
-		sd->generated = true;
-		return;
-	}
-
-	fprintf(stderr, "Cannot load %s, generating it\n", sd->filename);
-
-	for (i = 0; i < sd->coord->max; i++)
-		sd->class[i] = sd->coord->max + 1;
-
-	for (i = 0; i < sd->coord->max; i++) {
-		if (sd->class[i] == sd->coord->max + 1) {
-			sd->unsym[nreps] = i;
-			sd->transtorep[i] = uf;
-			sd->selfsim[nreps] = (uint64_t)0;
-			for (j = 0; j < sd->ntrans; j++) {
-				t = sd->trans[j];
-				in = sd->transform(t, i);
-				sd->class[in] = nreps;
-				if (in == i)
-					sd->selfsim[nreps] |=
-					    ((uint64_t)1 << t);
-				else
-					sd->transtorep[in] = inverse_trans(t);
-			}
-			nreps++;
-		}
-	}
-
-	sd->sym_coord->max = nreps;
-	sd->unsym          = realloc(sd->unsym,   nreps * sizeof(uint64_t));
-	sd->selfsim        = realloc(sd->selfsim, nreps * sizeof(uint64_t));
-	sd->generated      = true;
-
-	fprintf(stderr, "Found %" PRIu64 " classes\n", nreps);
-
-	if (!write_symdata_file(sd))
-		fprintf(stderr, "Error writing SymData file\n");
-
-	return;
-}
-
-static bool
-read_symdata_file(SymData *sd)
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+100];
-	uint64_t n = sd->coord->max, *sn = &sd->sym_coord->max;
-	bool r = true;
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/");
-	strcat(fname, sd->filename);
-
-	if ((f = fopen(fname, "rb")) == NULL)
-		return false;
-
-	r = r && fread(&sd->sym_coord->max, sizeof(uint64_t), 1,   f) == 1;
-	r = r && fread(sd->unsym,           sizeof(uint64_t), *sn, f) == *sn;
-	r = r && fread(sd->selfsim,         sizeof(uint64_t), *sn, f) == *sn;
-	r = r && fread(sd->class,           sizeof(uint64_t), n,   f) == n;
-	r = r && fread(sd->transtorep,      sizeof(Trans),    n,   f) == n;
-
-	fclose(f);
-	return r;
-}
-
-static bool
-read_symc_moves_file()
-{
-	init_env();
-
-	Move m;
-	bool r = true;
-	FILE *f;
-	char fname[strlen(tabledir)+100];
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/symc_moves");
-
-	if ((f = fopen(fname, "rb")) == NULL)
-		return false;
-
-	for (m = 0; m < NMOVES; m++) {
-		r = r && fread(move_cp_16[m], sizeof(uint64_t),
-		    CLASSES_CP_16, f) == CLASSES_CP_16;
-		r = r && fread(move_eofbepos_16[m], sizeof(uint64_t),
-		    CLASSES_EOFBEPOS_16, f) == CLASSES_EOFBEPOS_16;
-
-		r = r && fread(ttrep_move_cp_16[m], sizeof(Trans),
-		    CLASSES_CP_16, f) == CLASSES_CP_16;
-		r = r && fread(ttrep_move_eofbepos_16[m], sizeof(Trans),
-		    CLASSES_EOFBEPOS_16, f) == CLASSES_EOFBEPOS_16;
-	}
-
-	fclose(f);
-	return r;
-}
-
-static bool
-read_symc_trans_file()
-{
-	init_env();
-
-	Trans t;
-	bool r = true;
-	FILE *f;
-	char fname[strlen(tabledir)+100];
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/symc_trans");
-
-	if ((f = fopen(fname, "rb")) == NULL)
-		return false;
-
-	for (t = 0; t < NTRANS; t++) {
-		r = r && fread(trans_eofbepos[t], sizeof(int),
-		    POW2TO11*BINOM12ON4, f) == POW2TO11*BINOM12ON4;
-		r = r && fread(trans_epud[t], sizeof(int),
-		    FACTORIAL8, f) == FACTORIAL8;
-		r = r && fread(trans_cpud_separate[t], sizeof(int),
-		    BINOM8ON4, f) == BINOM8ON4;
-	}
-
-	fclose(f);
-	return r;
-}
-
-static bool
-write_symdata_file(SymData *sd)
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+100];
-	uint64_t n = sd->coord->max, *sn = &sd->sym_coord->max;
-	bool r = true;
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/");
-	strcat(fname, sd->filename);
-
-	if ((f = fopen(fname, "wb")) == NULL)
-		return false;
-
-	r = r && fwrite(&sd->sym_coord->max, sizeof(uint64_t), 1,   f) == 1;
-	r = r && fwrite(sd->unsym,           sizeof(uint64_t), *sn, f) == *sn;
-	r = r && fwrite(sd->selfsim,         sizeof(uint64_t), *sn, f) == *sn;
-	r = r && fwrite(sd->class,           sizeof(uint64_t), n,   f) == n;
-	r = r && fwrite(sd->transtorep,      sizeof(Trans),    n,   f) == n;
-
-	fclose(f);
-	return r;
-}
-
-static bool
-write_symc_moves_file()
-{
-	init_env();
-
-	Move m;
-	bool r = true;
-	FILE *f;
-	char fname[strlen(tabledir)+100];
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/symc_moves");
-
-	if ((f = fopen(fname, "wb")) == NULL)
-		return false;
-
-	for (m = 0; m < NMOVES; m++) {
-		r = r && fwrite(move_cp_16[m], sizeof(uint64_t),
-		    CLASSES_CP_16, f) == CLASSES_CP_16;
-		r = r && fwrite(move_eofbepos_16[m], sizeof(uint64_t),
-		    CLASSES_EOFBEPOS_16, f) == CLASSES_EOFBEPOS_16;
-
-		r = r && fwrite(ttrep_move_cp_16[m], sizeof(Trans),
-		    CLASSES_CP_16, f) == CLASSES_CP_16;
-		r = r && fwrite(ttrep_move_eofbepos_16[m], sizeof(Trans),
-		    CLASSES_EOFBEPOS_16, f) == CLASSES_EOFBEPOS_16;
-	}
-
-	fclose(f);
-	return r;
-}
-
-static bool
-write_symc_trans_file()
-{
-	init_env();
-
-	Trans t;
-	bool r = true;
-	FILE *f;
-	char fname[strlen(tabledir)+100];
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/symc_trans");
-
-	if ((f = fopen(fname, "wb")) == NULL)
-		return false;
-
-	for (t = 0; t < NTRANS; t++) {
-		r = r && fwrite(trans_eofbepos[t], sizeof(int),
-		    POW2TO11*BINOM12ON4, f) == POW2TO11*BINOM12ON4;
-		r = r && fwrite(trans_epud[t], sizeof(int),
-		    FACTORIAL8, f) == FACTORIAL8;
-		r = r && fwrite(trans_cpud_separate[t], sizeof(int),
-		    BINOM8ON4, f) == BINOM8ON4;
-	}
-
-	fclose(f);
-	return r;
-}
-
-static void
-init_symc_moves()
-{
-	uint64_t i, ii, coo;
-	Move j;
-
-	if (read_symc_moves_file())
-		return;
-
-	for (i = 0; i < CLASSES_CP_16; i++) {
-		ii = sd_cp_16.unsym[i];
-		for (j = 0; j < NMOVES; j++) {
-			coo = sd_cp_16.coord->move(j, ii);
-			move_cp_16[j][i] = sd_cp_16.class[coo];
-			ttrep_move_cp_16[j][i] = sd_cp_16.transtorep[coo];
-		}
-	}
-
-	for (i = 0; i < CLASSES_EOFBEPOS_16; i++) {
-		ii = sd_eofbepos_16.unsym[i];
-		for (j = 0; j < NMOVES; j++) {
-			coo = sd_eofbepos_16.coord->move(j, ii);
-			move_eofbepos_16[j][i] = sd_eofbepos_16.class[coo];
-			ttrep_move_eofbepos_16[j][i] =
-			    sd_eofbepos_16.transtorep[coo];
-		}
-	}
-
-	if (!write_symc_moves_file())
-		fprintf(stderr, "Error writing SymMoves file\n");
-}
-
-void
-init_symc_trans()
-{
-	uint64_t i;
-	int j, cp;
-	int epe[4] = {FR, FL, BL, BR};
-	int a[12] = { [8] = 8, [9] = 9, [10] = 10, [11] = 11 };
-	Cube c;
-	CubeArray *arr, *aux;
-	Trans t;
-
-	if (read_symc_trans_file())
-		return;
-
-	for (i = 0; i < POW2TO11*BINOM12ON4; i++) {
-		for (j = 0; j < 16; j++) {
-			t = trans_group_udfix[j];
-
-			arr = new_cubearray((Cube){0}, pf_edges);
-			int_to_sum_zero_array(i % POW2TO11, 2, 12, arr->eofb);
-			epos_to_compatible_ep((i / POW2TO11)*24, arr->ep, epe);
-			fix_eorleoud(arr);
-			c = arrays_to_cube(arr, pf_edges);
-			free_cubearray(arr, pf_edges);
-
-			c = apply_trans(t, c);
-			trans_eofbepos[t][i] = (c.epose/24)*POW2TO11 + c.eofb;
-		}
-	}
-
-	aux = malloc(sizeof(CubeArray));
-	aux->ep = a;
-	for (i = 0; i < FACTORIAL8; i++) {
-		index_to_perm(i, 8, a);
-		c = arrays_to_cube(aux, pf_ep);
-		for (j = 0; j < 16; j++) {
-			t = trans_group_udfix[j];
-			arr = new_cubearray(apply_trans(t, c), pf_ep);
-			trans_epud[t][i] = perm_to_index(arr->ep, 8);
-			free_cubearray(arr, pf_ep);
-		}
-	}
-	free(aux);
-
-	for (i = 0; i < BINOM8ON4; i++) {
-		cp = cpud_separate_ant[i];
-		for (j = 0; j < 16; j++) {
-			t = trans_group_udfix[j];
-			trans_cpud_separate[t][i] =
-			    cpud_separate_ind[cp_ttable[t][cp]];
-		}
-	}
-
-	if (!write_symc_trans_file())
-		fprintf(stderr, "Error writing SymTrans file\n");
-}
-
-void
-init_symcoord()
-{
-	int i;
-
-	static bool initialized = false;
-	if (initialized)
-		return;
-	initialized = true;
-
-	init_coord();
-
-	init_symc_trans();
-
-	for (i = 0; all_sd[i] != NULL; i++)
-		gensym(all_sd[i]);
-
-	init_symc_moves();
-}
-
diff --git a/src/symcoord.h b/src/symcoord.h
@@ -1,17 +0,0 @@
-#ifndef SYMCOORD_H
-#define SYMCOORD_H
-
-#include "coord.h"
-
-extern Coordinate       coord_cp_sym16;
-extern Coordinate       coord_eofbepos_sym16;
-extern Coordinate       coord_drud_sym16;
-extern Coordinate       coord_drudfin_noE_sym16;
-extern Coordinate       coord_nxopt31;
-
-extern SymData          *all_sd[];
-
-void                    free_sd(SymData *sd);
-void                    init_symcoord();
-
-#endif
diff --git a/src/trans.c b/src/trans.c
@@ -1,31 +1,23 @@
+#define TRANS_C
+
 #include "trans.h"
 
 /* Local functions ***********************************************************/
 
-static bool        read_ttables_file();
-static Cube        rotate_via_compose(Trans r, Cube c, PieceFilter f);
-static bool        write_ttables_file();
-
 /* Tables and other data *****************************************************/
 
-static int              ep_mirror[12] = {
-	[UF] = UF, [UL] = UR, [UB] = UB, [UR] = UL,
+static Cube mirror_cube = {
+.ep = { [UF] = UF, [UL] = UR, [UB] = UB, [UR] = UL,
 	[DF] = DF, [DL] = DR, [DB] = DB, [DR] = DL,
-	[FR] = FL, [FL] = FR, [BL] = BR, [BR] = BL
-};
-
-static int              cp_mirror[8] = {
-	[UFR] = UFL, [UFL] = UFR, [UBL] = UBR, [UBR] = UBL,
-	[DFR] = DFL, [DFL] = DFR, [DBL] = DBR, [DBR] = DBL
-};
-
-static int              cpos_mirror[6] = {
-	[U_center] = U_center, [D_center] = D_center,
+	[FR] = FL, [FL] = FR, [BL] = BR, [BR] = BL },
+.cp = { [UFR] = UFL, [UFL] = UFR, [UBL] = UBR, [UBR] = UBL,
+	[DFR] = DFL, [DFL] = DFR, [DBL] = DBR, [DBR] = DBL },
+.xp = { [U_center] = U_center, [D_center] = D_center,
 	[R_center] = L_center, [L_center] = R_center,
-	[F_center] = F_center, [B_center] = B_center
+	[F_center] = F_center, [B_center] = B_center }
 };
 
-static char             rotation_alg_string[100][NROTATIONS] = {
+static char rotation_alg_string[100][NROTATIONS] = {
 	[uf] = "",     [ur] = "y",    [ub] = "y2",    [ul] = "y3",
 	[df] = "z2",   [dr] = "y z2", [db] = "x2",    [dl] = "y3 z2",
 	[rf] = "z3",   [rd] = "z3 y", [rb] = "z3 y2", [ru] = "z3 y3",
@@ -34,176 +26,39 @@ static char             rotation_alg_string[100][NROTATIONS] = {
 	[bu] = "x3",   [br] = "x3 y", [bd] = "x3 y2", [bl] = "x3 y3",
 };
 
-static int              epose_source[NTRANS];  /* 0=epose, 1=eposs, 2=eposm */
-static int              eposs_source[NTRANS];
-static int              eposm_source[NTRANS];
-static int              eofb_source[NTRANS];   /* 0=eoud,  1=eorl,  2=eofb  */
-static int              eorl_source[NTRANS];
-static int              eoud_source[NTRANS];
-static int              coud_source[NTRANS];   /* 0=coud,  1=corl,  2=cofb  */
-static int              cofb_source[NTRANS];
-static int              corl_source[NTRANS];
+static Alg *rotation_alg_arr[NROTATIONS];
+Move  moves_ttable[NTRANS][NMOVES];
+Trans trans_ttable[NTRANS][NTRANS];
+Trans trans_itable[NTRANS];
 
-int                     epose_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
-int                     eposs_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
-int                     eposm_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
-int                     eo_ttable[NTRANS][POW2TO11];
-int                     cp_ttable[NTRANS][FACTORIAL8];
-int                     co_ttable[NTRANS][POW3TO7];
-int                     cpos_ttable[NTRANS][FACTORIAL6];
-Move                    moves_ttable[NTRANS][NMOVES];
-
-/* Local functions implementation ********************************************/
+/* Public functions **********************************************************/
 
-static bool
-read_ttables_file()
+void
+apply_trans(Trans t, Cube *cube)
 {
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+20];
-	int b = sizeof(int);
-	bool r = true;
-	Move m;
-
-	/* Table sizes, used for reading and writing files */
-	uint64_t me[11] = {
-		[0] = FACTORIAL12/FACTORIAL8,
-		[1] = FACTORIAL12/FACTORIAL8,
-		[2] = FACTORIAL12/FACTORIAL8,
-		[3] = POW2TO11,
-		[4] = FACTORIAL8,
-		[5] = POW3TO7,
-		[6] = FACTORIAL6,
-		[7] = NMOVES
-	};
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/");
-	strcat(fname, "ttables");
-
-	if ((f = fopen(fname, "rb")) == NULL)
-		return false;
+	Cube aux;
+	Alg *inv;
+	int i;
 
-	for (m = 0; m < NTRANS; m++) {
-		r = r && fread(epose_ttable[m], b, me[0], f) == me[0];
-		r = r && fread(eposs_ttable[m], b, me[1], f) == me[1];
-		r = r && fread(eposm_ttable[m], b, me[2], f) == me[2];
-		r = r && fread(eo_ttable[m],    b, me[3], f) == me[3];
-		r = r && fread(cp_ttable[m],    b, me[4], f) == me[4];
-		r = r && fread(co_ttable[m],    b, me[5], f) == me[5];
-		r = r && fread(cpos_ttable[m],  b, me[6], f) == me[6];
-		r = r && fread(moves_ttable[m], b, me[7], f) == me[7];
+	inv = inverse_alg(rotation_alg(t % NROTATIONS));
+	copy_cube(cube, &aux);
+	make_solved(cube);
+
+	if (t >= NROTATIONS)
+		compose(&mirror_cube, cube);
+	apply_alg(inv, cube);
+	compose(&aux, cube);
+	apply_alg(rotation_alg(t % NROTATIONS), cube);
+	if (t >= NROTATIONS) {
+		compose(&mirror_cube, cube);
+		for (i = 0; i < 8; i++)
+			cube->co[i] = (3 - cube->co[i]) % 3;
 	}
 
-	fclose(f);
-	return r;
-}
-
-static Cube
-rotate_via_compose(Trans r, Cube c, PieceFilter f)
-{
-	static int zero12[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-	static int zero8[8]   = { 0, 0, 0, 0, 0, 0, 0, 0 };
-	static CubeArray ma = {
-		.ep   = ep_mirror,
-		.eofb = zero12,
-		.eorl = zero12,
-		.eoud = zero12,
-		.cp   = cp_mirror,
-		.coud = zero8,
-		.corl = zero8,
-		.cofb = zero8,
-		.cpos = cpos_mirror
-	};
-
-	Alg *inv = inverse_alg(rotation_alg(r));
-	Cube ret = {0};
-
-	if (r >= NROTATIONS)
-		ret = move_via_arrays(&ma, ret, f);
-	ret = apply_alg_generic(inv, ret, f, true);
-
-	ret = compose_filtered(c, ret, f);
-
-	ret = apply_alg_generic(rotation_alg(r), ret, f, true);
-	if (r >= NROTATIONS)
-		ret = move_via_arrays(&ma, ret, f);
-
 	free_alg(inv);
-	return ret;
-}
-
-static bool
-write_ttables_file()
-{
-	init_env();
-
-	FILE *f;
-	char fname[strlen(tabledir)+20];
-	bool r = true;
-	int b = sizeof(int);
-	Move m;
-
-	/* Table sizes, used for reading and writing files */
-	uint64_t me[11] = {
-		[0] = FACTORIAL12/FACTORIAL8,
-		[1] = FACTORIAL12/FACTORIAL8,
-		[2] = FACTORIAL12/FACTORIAL8,
-		[3] = POW2TO11,
-		[4] = FACTORIAL8,
-		[5] = POW3TO7,
-		[6] = FACTORIAL6,
-		[7] = NMOVES
-	};
-
-	strcpy(fname, tabledir);
-	strcat(fname, "/ttables");
-
-	if ((f = fopen(fname, "wb")) == NULL)
-		return false;
-
-	for (m = 0; m < NTRANS; m++) {
-		r = r && fwrite(epose_ttable[m], b, me[0], f) == me[0];
-		r = r && fwrite(eposs_ttable[m], b, me[1], f) == me[1];
-		r = r && fwrite(eposm_ttable[m], b, me[2], f) == me[2];
-		r = r && fwrite(eo_ttable[m],    b, me[3], f) == me[3];
-		r = r && fwrite(cp_ttable[m],    b, me[4], f) == me[4];
-		r = r && fwrite(co_ttable[m],    b, me[5], f) == me[5];
-		r = r && fwrite(cpos_ttable[m],  b, me[6], f) == me[6];
-		r = r && fwrite(moves_ttable[m], b, me[7], f) == me[7];
-	}
-
-	fclose(f);
-	return r;
-}
-
-/* Public functions **********************************************************/
-
-Cube
-apply_trans(Trans t, Cube cube)
-{
-	/*init_trans();*/
-
-	int aux_epos[3] = { cube.epose, cube.eposs, cube.eposm };
-	int aux_eo[3]   = { cube.eoud,  cube.eorl,  cube.eofb  };
-	int aux_co[3]   = { cube.coud,  cube.corl,  cube.cofb  };
-
-	return (Cube) {
-		.epose = epose_ttable[t][aux_epos[epose_source[t]]],
-		.eposs = eposs_ttable[t][aux_epos[eposs_source[t]]],
-		.eposm = eposm_ttable[t][aux_epos[eposm_source[t]]],
-		.eofb  = eo_ttable[t][aux_eo[eofb_source[t]]],
-		.eorl  = eo_ttable[t][aux_eo[eorl_source[t]]],
-		.eoud  = eo_ttable[t][aux_eo[eoud_source[t]]],
-		.coud  = co_ttable[t][aux_co[coud_source[t]]],
-		.corl  = co_ttable[t][aux_co[corl_source[t]]],
-		.cofb  = co_ttable[t][aux_co[cofb_source[t]]],
-		.cp    = cp_ttable[t][cube.cp],
-		.cpos  = cpos_ttable[t][cube.cpos]
-	};
 }
 
+/*
 Trans
 inverse_trans(Trans t)
 {
@@ -231,23 +86,18 @@ inverse_trans(Trans t)
 
 	return inverse_trans_aux[t];
 }
+*/
 
-Alg *
-rotation_alg(Trans t)
+Trans
+inverse_trans(Trans t)
 {
-	int i;
-
-	static Alg *rotation_alg_arr[NROTATIONS];
-	static bool initialized = false;
-
-	if (!initialized) {
-		for (i = 0; i < NROTATIONS; i++)
-			rotation_alg_arr[i] = new_alg(rotation_alg_string[i]);
-
-		initialized = true;
-	}
+	return trans_itable[t];
+}
 
-	return rotation_alg_arr[t % NROTATIONS];
+Alg *
+rotation_alg(Trans i)
+{
+	return rotation_alg_arr[i % NROTATIONS];
 }
 
 void
@@ -255,10 +105,20 @@ transform_alg(Trans t, Alg *alg)
 {
 	int i;
 
-	/*init_trans();*/
-	
 	for (i = 0; i < alg->len; i++)
-		alg->move[i] = moves_ttable[t][alg->move[i]];
+		alg->move[i] = transform_move(t, alg->move[i]);
+}
+
+Move
+transform_move(Trans t, Move m)
+{
+	return moves_ttable[t][m];
+}
+
+Trans
+transform_trans(Trans t, Trans m)
+{
+	return trans_ttable[t][m];
 }
 
 void
@@ -268,106 +128,63 @@ init_trans() {
 		return;
 	initialized = true;
 
-	init_moves();
-
-	Cube aux, cube, c[3];
-	CubeArray epcp;
-	int i, eparr[12], eoarr[12], cparr[8], coarr[8];
-	unsigned int ui;
+	int i;
+	Alg *nonsym_alg, *nonsym_inv;
+	Cube aux, cube;
 	Move mi, move;
-	Trans m;
+	Trans t, u, v;
 
-	/* Compute sources */
-	for (i = 0; i < NTRANS; i++) {
-		cube = apply_alg(rotation_alg(i), (Cube){0});
-
-		epose_source[i] = edge_slice(what_edge_at(cube, FR));
-		eposs_source[i] = edge_slice(what_edge_at(cube, UR));
-		eposm_source[i] = edge_slice(what_edge_at(cube, UF));
-		eofb_source[i]  = what_center_at(cube, F_center)/2;
-		eorl_source[i]  = what_center_at(cube, R_center)/2;
-		eoud_source[i]  = what_center_at(cube, U_center)/2;
-		coud_source[i]  = what_center_at(cube, U_center)/2;
-		cofb_source[i]  = what_center_at(cube, F_center)/2;
-		corl_source[i]  = what_center_at(cube, R_center)/2;
-	}
-
-	if (read_ttables_file())
-		return;
-
-	fprintf(stderr, "Cannot load %s, generating it\n", "ttables"); 
-
-	/* Initialize tables */
-	for (m = 0; m < NTRANS; m++) {
-		epcp = (CubeArray){ .ep = eparr, .cp = cparr };
-		cube = apply_alg(rotation_alg(m), (Cube){0});
-		cube_to_arrays(cube, &epcp, pf_epcp);
-		if (m >= NROTATIONS) {
-			apply_permutation(ep_mirror, eparr, 12);
-			apply_permutation(cp_mirror, cparr,  8);
-		}
-
-		for (ui = 0; ui < FACTORIAL12/FACTORIAL8; ui++) {
-			c[0] = admissible_ep((Cube){ .epose = ui }, pf_e);
-			c[1] = admissible_ep((Cube){ .eposs = ui }, pf_s);
-			c[2] = admissible_ep((Cube){ .eposm = ui }, pf_m);
-
-			cube = rotate_via_compose(m,c[epose_source[m]],pf_ep);
-			epose_ttable[m][ui] = cube.epose;
+	init_moves();
 
-			cube = rotate_via_compose(m,c[eposs_source[m]],pf_ep);
-			eposs_ttable[m][ui] = cube.eposs;
+	for (i = 0; i < NROTATIONS; i++)
+		rotation_alg_arr[i] = new_alg(rotation_alg_string[i]);
 
-			cube = rotate_via_compose(m,c[eposm_source[m]],pf_ep);
-			eposm_ttable[m][ui] = cube.eposm;
-		}
-		for (ui = 0; ui < POW2TO11; ui++ ) {
-			int_to_sum_zero_array(ui, 2, 12, eoarr);
-			apply_permutation(eparr, eoarr, 12);
-			eo_ttable[m][ui] = digit_array_to_int(eoarr, 11, 2);
-		}
-		for (ui = 0; ui < POW3TO7; ui++) {
-			int_to_sum_zero_array(ui, 3, 8, coarr);
-			apply_permutation(cparr, coarr, 8);
-			co_ttable[m][ui] = digit_array_to_int(coarr, 7, 3);
-			if (m >= NROTATIONS)
-				co_ttable[m][ui] =
-					invert_digits(co_ttable[m][ui], 3, 7);
-		}
-		for (ui = 0; ui < FACTORIAL8; ui++) {
-			cube = (Cube){ .cp = ui };
-			cube = rotate_via_compose(m, cube, pf_cp);
-			cp_ttable[m][ui] = cube.cp;
-		}
-		for (ui = 0; ui < FACTORIAL6; ui++) {
-			cube = (Cube){ .cpos = ui };
-			cube = rotate_via_compose(m, cube, pf_cpos);
-			cpos_ttable[m][ui] = cube.cpos;
-		}
+	for (t = 0; t < NTRANS; t++) {
 		for (mi = 0; mi < NMOVES; mi++) {
-			/* Old version:
-			 *
-			aux = apply_trans(m, apply_move(mi, (Cube){0}));
+			make_solved(&aux);
+			apply_move(mi, &aux);
+			apply_trans(t, &aux);
 			for (move = 0; move < NMOVES; move++) {
-				cube = apply_move(inverse_move(move), aux);
-				mirr = apply_trans(uf_mirror, cube);
-				if (is_solved(cube) || is_solved(mirr))
-					moves_ttable[m][mi] = move;
+				copy_cube(&aux, &cube);
+				apply_move(inverse_move(move), &cube);
+				if (is_solved(&cube)) {
+					moves_ttable[t][mi] = move;
+					break;
+				}
 			}
-			*/
+		}
+	}
 
-			aux = apply_trans(m, apply_move(mi, (Cube){0}));
-			for (move = 0; move < NMOVES; move++) {
-				cube = apply_move(inverse_move(move), aux);
-				if (is_solved(cube)) {
-					moves_ttable[m][mi] = move;
+	nonsym_alg = new_alg("R' U' F");
+	nonsym_inv = inverse_alg(nonsym_alg);
+		
+	for (t = 0; t < NTRANS; t++) {
+		for (u = 0; u < NTRANS; u++) {
+			make_solved(&aux);
+			apply_alg(nonsym_alg, &aux);
+			apply_trans(u, &aux);
+			apply_trans(t, &aux);
+			for (v = 0; v < NTRANS; v++) {
+				copy_cube(&aux, &cube);
+				apply_trans(v, &cube);
+				apply_alg(nonsym_inv, &cube);
+				if (is_solved(&cube)) {
+					/* This is the inverse of the correct
+					   value, it will be inverted later */
+					trans_ttable[t][u] = v;
+					if (v == uf)
+						trans_itable[t] = u;
 					break;
 				}
 			}
 		}
 	}
+	for (t = 0; t < NTRANS; t++)
+		for (u = 0; u < NTRANS; u++)
+			trans_ttable[t][u] = trans_itable[trans_ttable[t][u]];
+
 
-	if (!write_ttables_file())
-		fprintf(stderr, "Error writing ttables\n");
+	free_alg(nonsym_alg);
+	free_alg(nonsym_inv);
 }
 
diff --git a/src/trans.h b/src/trans.h
@@ -3,24 +3,30 @@
 
 #include "moves.h"
 
-/*
- * Tables are exposed to allow faster partial transformations in some
- * specific cases (in symcoord)
- */
-extern int               epose_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
-extern int               eposs_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
-extern int               eposm_ttable[NTRANS][FACTORIAL12/FACTORIAL8];
-extern int               eo_ttable[NTRANS][POW2TO11];
-extern int               cp_ttable[NTRANS][FACTORIAL8];
-extern int               co_ttable[NTRANS][POW3TO7];
-extern int               cpos_ttable[NTRANS][FACTORIAL6];
-extern Move              moves_ttable[NTRANS][NMOVES];
-
-Cube        apply_trans(Trans t, Cube cube);
+void        apply_trans(Trans t, Cube *cube);
 Trans       inverse_trans(Trans t);
 Alg *       rotation_alg(Trans i);
-void        transform_alg(Trans i, Alg *alg);
+void        transform_alg(Trans t, Alg *alg);
+Move        transform_move(Trans t, Move m);
+Trans       transform_trans(Trans t, Trans m);
 
 void        init_trans();
 
+#ifndef TRANS_C
+
+extern TransGroup tgrp_udfix;
+
+#else
+
+TransGroup
+tgrp_udfix = {
+	.n = 16,
+	.t = { uf, ur, ub, ul,
+	       df, dr, db, dl,
+	       uf_mirror, ur_mirror, ub_mirror, ul_mirror,
+	       df_mirror, dr_mirror, db_mirror, dl_mirror },
+};
+
+#endif
+
 #endif
diff --git a/src/utils.c b/src/utils.c
@@ -1,3 +1,5 @@
+#define UTILS_C
+
 #include "utils.h"
 
 void
@@ -159,24 +161,24 @@ is_perm(int *a, int n)
 {
 	int *aux = malloc(n * sizeof(int));
 	int i;
+	bool ret = true;
 
 	for (i = 0; i < n; i++)
 		aux[i] = 0;
 	
 	for (i = 0; i < n; i++) {
 		if (a[i] < 0 || a[i] >= n)
-			return false;
+			ret = false;
 		else
 			aux[a[i]] = 1;
 	}
 
 	for (i = 0; i < n; i++)
 		if (!aux[i])
-			return false;
+			ret = false;
 
 	free(aux);
-
-	return true;
+	return ret;
 }
 
 bool
@@ -195,7 +197,7 @@ perm_sign(int *a, int n)
 {
 	int i, j, ret = 0;
 
-	if (!is_perm(a,n))
+	if (!is_perm(a, n))
 		return -1;
 
 	for (i = 0; i < n; i++)
@@ -211,7 +213,7 @@ perm_to_index(int *a, int n)
 	int i, j, c, ret = 0;
 
 	if (!is_perm(a, n))
-		return -1;
+		return factorial(n);
 
 	for (i = 0; i < n; i++) {
 		c = 0;
diff --git a/www/download/index.html b/www/download/index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 	<title> Download | Nissy </title>
-<meta name="viewport" content="width=device-width" />	<link rel="stylesheet" type="text/css" href="/style.css">
+<meta name="viewport" content="width=device-width" />	<link rel="stylesheet" type="text/css" href="/style-3.css">
 	<link rel="icon" href="/favicon.png">
 	<meta charset="utf-8">
 </head>
diff --git a/www/examples/index.html b/www/examples/index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 	<title> Examples | Nissy </title>
-<meta name="viewport" content="width=device-width" />	<link rel="stylesheet" type="text/css" href="/style.css">
+<meta name="viewport" content="width=device-width" />	<link rel="stylesheet" type="text/css" href="/style-3.css">
 	<link rel="icon" href="/favicon.png">
 	<meta charset="utf-8">
 </head>
diff --git a/www/index.html b/www/index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 	<title> Nissy | Nissy </title>
-<meta name="viewport" content="width=device-width" />	<link rel="stylesheet" type="text/css" href="/style.css">
+<meta name="viewport" content="width=device-width" />	<link rel="stylesheet" type="text/css" href="/style-3.css">
 	<link rel="icon" href="/favicon.png">
 	<meta charset="utf-8">
 </head>
diff --git a/www/style-2.css b/www/style-2.css
@@ -0,0 +1,105 @@
+.menu {
+	width:			100%;
+}
+
+.links {
+	text-align:		right;
+	font-weight:		bold;
+}
+
+.logo img {
+	width:			50px;
+	height:			50px;
+}
+
+.footer {
+	font-style:		italic;
+	width:			100%;
+}
+
+.hosted {
+	text-align:		right;
+}
+
+body {
+	margin:			auto 8px 20px 8px;
+}
+
+img {
+	display:		block;
+	margin-left:		auto;
+	margin-right:		auto;
+	max-width:		100%;
+}
+
+code {
+	background-color:	#eeeeee;
+	padding:		2px;
+}
+
+pre code {
+	padding:                0px;
+}
+
+pre {
+	background-color:	#eeeeee;
+	border:			2px solid;
+	padding:		6px;
+}
+
+#blob {
+	background:		#ffffff;
+	border:			none;
+}
+
+a {
+	color:			#0f2899;
+	text-decoration:	none;
+}
+
+.links a {
+	font-weight:		bold;
+	color:			black;
+}
+
+.hosted a,
+.contact a {
+	font-weight:		bold;
+}
+
+a:hover {
+	text-decoration:	underline;
+}
+
+html {
+	margin:			1em auto;
+	max-width:		42em;
+}
+
+h1 {
+	text-align:		center;
+}
+
+td h1 {
+	text-align:		left;
+	font-size:		1.5em;
+}
+
+table {
+	width:			100%;
+}
+
+.url td {
+	font-family:		monospace;
+}
+
+.dltable th, .dltable td {
+	border:			1px solid black;
+	padding:		3px;
+}
+
+.subtitle {
+	text-align:		center;
+	font-weight:		bold;
+	font-size:		1.1em;
+}
diff --git a/www/style.css b/www/style.css
@@ -1,99 +0,0 @@
-.menu {
-	width:			100%;
-}
-
-.links {
-	text-align:		right;
-	font-weight:		bold;
-}
-
-.logo img {
-	width:			50px;
-	height:			50px;
-}
-
-.footer {
-	font-style:		italic;
-	width:			100%;
-}
-
-.hosted {
-	text-align:		right;
-}
-
-body {
-	margin:			auto 8px 20px 8px;
-}
-
-img {
-	display:		block;
-	margin-left:		auto;
-	margin-right:		auto;
-	max-width:		100%;
-}
-
-pre, code {
-	background-color:	#eeeeee;
-}
-
-pre {
-	border:			2px solid;
-	padding:		6px;
-}
-
-#blob {
-	background:		#ffffff;
-	border:			none;
-}
-
-a {
-	color:			#0f2899;
-	text-decoration:	none;
-}
-
-.links a {
-	font-weight:		bold;
-	color:			black;
-}
-
-.hosted a,
-.contact a {
-	font-weight:		bold;
-}
-
-a:hover {
-	text-decoration:	underline;
-}
-
-html {
-	margin:			1em auto;
-	max-width:		42em;
-}
-
-h1 {
-	text-align:		center;
-}
-
-td h1 {
-	text-align:		left;
-	font-size:		1.5em;
-}
-
-table {
-	width:			100%;
-}
-
-.url td {
-	font-family:		monospace;
-}
-
-.dltable th, .dltable td {
-	border:			1px solid black;
-	padding:		3px;
-}
-
-.subtitle {
-	text-align:		center;
-	font-weight:		bold;
-	font-size:		1.1em;
-}

	nissy Where is nissy?
	git clone https://git.tronto.net/nissy
	Download \| Log \| Files \| Refs \| README

M	Makefile	\|	5	++---
M	TODO.md	\|	111	++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------
D	doc/nissy.1	\|	271	-------------------------------------------------------------------------------
A	old/maybe-useful-coord.c	\|	181	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	old/maybe-useful-steps.c	\|	1111	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M	src/alg.c	\|	105	++++++++++++++++++++++++++++---------------------------------------------------
M	src/alg.h	\|	76	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
M	src/commands.c	\|	324	+++++++++++++++----------------------------------------------------------------
M	src/commands.h	\|	194	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
M	src/coord.c	\|	992	++++++++++++++++++++++++++++++++++++++++++-------------------------------------
M	src/coord.h	\|	246	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
M	src/cube.c	\|	920	+++++++------------------------------------------------------------------------
M	src/cube.h	\|	44	+++++++++-----------------------------------
M	src/cubetypes.h	\|	176	+++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/env.c	\|	2	++
M	src/env.h	\|	4	++--
M	src/moves.c	\|	409	++++++++++++++-----------------------------------------------------------------
M	src/moves.h	\|	20	++------------------
D	src/pf.c	\|	95	-------------------------------------------------------------------------------
D	src/pf.h	\|	20	--------------------
M	src/pruning.c	\|	265	++++++++++++++++++++++++-------------------------------------------------------
M	src/pruning.h	\|	21	+++++----------------
M	src/shell.c	\|	22	+++++++++++++++++++++-
M	src/solve.c	\|	485	++++++++++++++++++++++++++++++++++++++-----------------------------------------
M	src/solve.h	\|	4	++--
M	src/steps.c	\|	1514	+++++++------------------------------------------------------------------------
M	src/steps.h	\|	276	++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
D	src/symcoord.c	\|	687	-------------------------------------------------------------------------------
D	src/symcoord.h	\|	17	-----------------
M	src/trans.c	\|	383	+++++++++++++++++++++----------------------------------------------------------
M	src/trans.h	\|	36	+++++++++++++++++++++---------------
M	src/utils.c	\|	14	++++++++------
M	www/download/index.html	\|	2	+-
M	www/examples/index.html	\|	2	+-
M	www/index.html	\|	2	+-
A	www/style-2.css	\|	105	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
D	www/style.css	\|	99	-------------------------------------------------------------------------------