commit fc08e3ca18bec97b554c7c68260d567da97454e9
Author: leszek <leszek@koltunski.pl>
Date:   Tue Dec 24 00:56:54 2024 +0100

    Unify the position verifiers (for verifying if a manually set position for solving is possible!)

diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseCU232.java b/src/main/java/org/distorted/solvers/SolverTablebaseCU232.java
index 6a80d22a..8b61ab90 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseCU232.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseCU232.java
@@ -20,25 +20,14 @@ import org.distorted.objectlib.tablebases.TablebaseHelpers;
 
 public class SolverTablebaseCU232 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_135_MISSING = -1;
-  private static final int ERROR_CORNER_134_MISSING = -2;
-  private static final int ERROR_CORNER_125_MISSING = -3;
-  private static final int ERROR_CORNER_124_MISSING = -4;
-  private static final int ERROR_CORNER_035_MISSING = -5;
-  private static final int ERROR_CORNER_034_MISSING = -6;
-  private static final int ERROR_CORNER_025_MISSING = -7;
-  private static final int ERROR_CORNER_024_MISSING = -8;
-
-  private static final int ERROR_EDGE_15_MISSING = -9;
-  private static final int ERROR_EDGE_14_MISSING = -10;
-  private static final int ERROR_EDGE_05_MISSING = -11;
-  private static final int ERROR_EDGE_04_MISSING = -12;
-
-  private static final int ERROR_CORNERS_CANNOT  = -13;
-  private static final int ERROR_EDGE_TWISTED    = -14;
-  private static final int ERROR_CORNER_TWISTED  = -15;
+  private static final int ERROR_CORNER_MISSING = -1;
+  private static final int ERROR_EDGE_MISSING   = -2;
+  private static final int ERROR_CORNERS_CANNOT = -3;
+  private static final int ERROR_EDGE_TWISTED   = -4;
+  private static final int ERROR_CORNER_TWISTED = -5;
 
   private final int[] mFaceColors;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -77,10 +66,10 @@ public class SolverTablebaseCU232 extends SolverTablebase
       else if( edge3==1 ) return ERROR_EDGE_TWISTED;
       }
 
-    if( output[0]==-1 ) return ERROR_EDGE_15_MISSING;
-    if( output[1]==-1 ) return ERROR_EDGE_14_MISSING;
-    if( output[2]==-1 ) return ERROR_EDGE_05_MISSING;
-    if( output[3]==-1 ) return ERROR_EDGE_04_MISSING;
+    if( output[0]==-1 ) { mErrColor1=1; mErrColor2=5; return ERROR_EDGE_MISSING; }
+    if( output[1]==-1 ) { mErrColor1=1; mErrColor2=4; return ERROR_EDGE_MISSING; }
+    if( output[2]==-1 ) { mErrColor1=0; mErrColor2=5; return ERROR_EDGE_MISSING; }
+    if( output[3]==-1 ) { mErrColor1=0; mErrColor2=4; return ERROR_EDGE_MISSING; }
 
     return 0;
     }
@@ -145,14 +134,14 @@ public class SolverTablebaseCU232 extends SolverTablebase
       else if( corner0==1 ) return ERROR_CORNER_TWISTED;
       }
 
-    if( output[0]==-1 ) return ERROR_CORNER_135_MISSING;
-    if( output[1]==-1 ) return ERROR_CORNER_134_MISSING;
-    if( output[2]==-1 ) return ERROR_CORNER_125_MISSING;
-    if( output[3]==-1 ) return ERROR_CORNER_124_MISSING;
-    if( output[4]==-1 ) return ERROR_CORNER_035_MISSING;
-    if( output[5]==-1 ) return ERROR_CORNER_034_MISSING;
-    if( output[6]==-1 ) return ERROR_CORNER_025_MISSING;
-    if( output[7]==-1 ) return ERROR_CORNER_024_MISSING;
+    if( output[0]==-1 ) { mErrColor1=1; mErrColor2=3; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( output[1]==-1 ) { mErrColor1=1; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( output[2]==-1 ) { mErrColor1=1; mErrColor2=2; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( output[3]==-1 ) { mErrColor1=1; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( output[4]==-1 ) { mErrColor1=0; mErrColor2=3; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( output[5]==-1 ) { mErrColor1=0; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( output[6]==-1 ) { mErrColor1=0; mErrColor2=2; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( output[7]==-1 ) { mErrColor1=0; mErrColor2=2; mErrColor3=4; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -326,23 +315,11 @@ public class SolverTablebaseCU232 extends SolverTablebase
     {
     switch(index)
       {
-      case ERROR_CORNER_135_MISSING: return cornerError(res,1,3,5);
-      case ERROR_CORNER_134_MISSING: return cornerError(res,1,3,4);
-      case ERROR_CORNER_125_MISSING: return cornerError(res,1,2,5);
-      case ERROR_CORNER_124_MISSING: return cornerError(res,1,2,4);
-      case ERROR_CORNER_035_MISSING: return cornerError(res,0,3,5);
-      case ERROR_CORNER_034_MISSING: return cornerError(res,0,3,4);
-      case ERROR_CORNER_025_MISSING: return cornerError(res,0,2,5);
-      case ERROR_CORNER_024_MISSING: return cornerError(res,0,2,4);
-
-      case ERROR_EDGE_15_MISSING   : return edgeError(res,1,5);
-      case ERROR_EDGE_14_MISSING   : return edgeError(res,1,4);
-      case ERROR_EDGE_05_MISSING   : return edgeError(res,0,5);
-      case ERROR_EDGE_04_MISSING   : return edgeError(res,0,4);
-
-      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
-      case ERROR_EDGE_TWISTED      : return res.getString(R.string.solver_generic_edge_twist);
-      case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);
+      case ERROR_CORNER_MISSING: return cornerError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_EDGE_MISSING  : return edgeError(res,mErrColor1,mErrColor2);
+      case ERROR_CORNERS_CANNOT: return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_EDGE_TWISTED  : return res.getString(R.string.solver_generic_edge_twist);
+      case ERROR_CORNER_TWISTED: return res.getString(R.string.solver_generic_corner_twist);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseCU323.java b/src/main/java/org/distorted/solvers/SolverTablebaseCU323.java
index d4f8732f..d371ec31 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseCU323.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseCU323.java
@@ -29,7 +29,7 @@ public class SolverTablebaseCU323 extends SolverTablebase
   private static final int ERROR_CORNER_TWISTED = -5;
 
   private final int[] mFaceColors;
-  private int mErrorColor1, mErrorColor2, mErrorColor3;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -88,14 +88,14 @@ public class SolverTablebaseCU323 extends SolverTablebase
       if( edge[0]==c0 && edge[1]==c1 ) return i;
       if( edge[0]==c1 && edge[1]==c0 )
         {
-        mErrorColor1 = c0;
-        mErrorColor2 = c1;
+        mErrColor1 = c0;
+        mErrColor2 = c1;
         return ERROR_EDGE_TWISTED;
         }
       }
 
-    mErrorColor1 = c0;
-    mErrorColor2 = c1;
+    mErrColor1 = c0;
+    mErrColor2 = c1;
     return ERROR_EDGE_MISSING;
     }
 
@@ -115,16 +115,16 @@ public class SolverTablebaseCU323 extends SolverTablebase
       if( (corner[0]==c1 && corner[1]==c2 && corner[2]==c0 ) ||
           (corner[0]==c2 && corner[1]==c0 && corner[2]==c1 )  )
         {
-        mErrorColor1 = c0;
-        mErrorColor2 = c1;
-        mErrorColor3 = c2;
+        mErrColor1 = c0;
+        mErrColor2 = c1;
+        mErrColor3 = c2;
         return ERROR_CORNER_TWISTED;
         }
       }
 
-    mErrorColor1 = c0;
-    mErrorColor2 = c1;
-    mErrorColor3 = c2;
+    mErrColor1 = c0;
+    mErrColor2 = c1;
+    mErrColor3 = c2;
     return ERROR_CORNER_MISSING;
     }
 
@@ -357,11 +357,11 @@ public class SolverTablebaseCU323 extends SolverTablebase
     {
     switch(index)
       {
-      case ERROR_CORNER_MISSING : return cornerMissingError(res,mErrorColor1,mErrorColor2,mErrorColor3);
-      case ERROR_EDGE_MISSING   : return edgeMissingError(res,mErrorColor1,mErrorColor2);
+      case ERROR_CORNER_MISSING : return cornerMissingError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_EDGE_MISSING   : return edgeMissingError(res,mErrColor1,mErrColor2);
       case ERROR_CORNERS_CANNOT : return res.getString(R.string.solver_generic_corners_cannot);
-      case ERROR_EDGE_TWISTED   : return edgeTwistedError(res,mErrorColor1,mErrorColor2);
-      case ERROR_CORNER_TWISTED : return cornerTwistedError(res,mErrorColor1,mErrorColor2,mErrorColor3);
+      case ERROR_EDGE_TWISTED   : return edgeTwistedError(res,mErrColor1,mErrColor2);
+      case ERROR_CORNER_TWISTED : return cornerTwistedError(res,mErrColor1,mErrColor2,mErrColor3);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseCUBE2.java b/src/main/java/org/distorted/solvers/SolverTablebaseCUBE2.java
index 3bee0086..7febc1f0 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseCUBE2.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseCUBE2.java
@@ -21,18 +21,12 @@ import org.distorted.objectlib.tablebases.TBCube2;
 
 public class SolverTablebaseCUBE2 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_135_MISSING = -1;
-  private static final int ERROR_CORNER_134_MISSING = -2;
-  private static final int ERROR_CORNER_125_MISSING = -3;
-  private static final int ERROR_CORNER_124_MISSING = -4;
-  private static final int ERROR_CORNER_035_MISSING = -5;
-  private static final int ERROR_CORNER_034_MISSING = -6;
-  private static final int ERROR_CORNER_025_MISSING = -7;
-  private static final int ERROR_CORNER_024_MISSING = -8;
-  private static final int ERROR_CORNERS_CANNOT     = -9;
-  private static final int ERROR_CORNER_TWISTED     = -10;
+  private static final int ERROR_CORNER_MISSING = -1;
+  private static final int ERROR_CORNERS_CANNOT = -2;
+  private static final int ERROR_CORNER_TWISTED = -3;
 
   private final int[] mFaceColors;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
@@ -83,14 +77,14 @@ public class SolverTablebaseCUBE2 extends SolverTablebase
     output[6] = cornerIndex(corners, 0,3,5);
     output[7] = cornerIndex(corners, 0,4,3);
 
-    if( output[0]==-1 ) return ERROR_CORNER_125_MISSING;
-    if( output[1]==-1 ) return ERROR_CORNER_124_MISSING;
-    if( output[2]==-1 ) return ERROR_CORNER_135_MISSING;
-    if( output[3]==-1 ) return ERROR_CORNER_134_MISSING;
-    if( output[4]==-1 ) return ERROR_CORNER_025_MISSING;
-    if( output[5]==-1 ) return ERROR_CORNER_024_MISSING;
-    if( output[6]==-1 ) return ERROR_CORNER_035_MISSING;
-    if( output[7]==-1 ) return ERROR_CORNER_034_MISSING;
+    if( output[0]==-1 ) { mErrColor1=1; mErrColor2=2; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( output[1]==-1 ) { mErrColor1=1; mErrColor2=4; mErrColor3=2; return ERROR_CORNER_MISSING; }
+    if( output[2]==-1 ) { mErrColor1=1; mErrColor2=5; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( output[3]==-1 ) { mErrColor1=1; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( output[4]==-1 ) { mErrColor1=0; mErrColor2=5; mErrColor3=2; return ERROR_CORNER_MISSING; }
+    if( output[5]==-1 ) { mErrColor1=0; mErrColor2=2; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( output[6]==-1 ) { mErrColor1=0; mErrColor2=3; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( output[7]==-1 ) { mErrColor1=0; mErrColor2=4; mErrColor3=3; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -229,16 +223,9 @@ public class SolverTablebaseCUBE2 extends SolverTablebase
     {
     switch(index)
       {
-      case ERROR_CORNER_135_MISSING: return cornerError(res,1,3,5);
-      case ERROR_CORNER_134_MISSING: return cornerError(res,1,3,4);
-      case ERROR_CORNER_125_MISSING: return cornerError(res,1,2,5);
-      case ERROR_CORNER_124_MISSING: return cornerError(res,1,2,4);
-      case ERROR_CORNER_035_MISSING: return cornerError(res,0,3,5);
-      case ERROR_CORNER_034_MISSING: return cornerError(res,0,3,4);
-      case ERROR_CORNER_025_MISSING: return cornerError(res,0,2,5);
-      case ERROR_CORNER_024_MISSING: return cornerError(res,0,2,4);
-      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
-      case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);
+      case ERROR_CORNER_MISSING: return cornerError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_CORNERS_CANNOT: return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_CORNER_TWISTED: return res.getString(R.string.solver_generic_corner_twist);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseDIAM2.java b/src/main/java/org/distorted/solvers/SolverTablebaseDIAM2.java
index 11017df3..ebad7a65 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseDIAM2.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseDIAM2.java
@@ -20,30 +20,16 @@ import org.distorted.objectlib.tablebases.TablebaseHelpers;
 
 public class SolverTablebaseDIAM2 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_FR_MISSING = -1;
-  private static final int ERROR_CORNER_BR_MISSING = -2;
-  private static final int ERROR_CORNER_BL_MISSING = -3;
-  private static final int ERROR_CORNER_FL_MISSING = -4;
-  private static final int ERROR_CORNER_TO_MISSING = -5;
-  private static final int ERROR_CORNER_BO_MISSING = -6;
-
-  private static final int ERROR_CENTER_0_MISSING = -7;
-  private static final int ERROR_CENTER_1_MISSING = -8;
-  private static final int ERROR_CENTER_2_MISSING = -9;
-  private static final int ERROR_CENTER_3_MISSING = -10;
-  private static final int ERROR_CENTER_4_MISSING = -11;
-  private static final int ERROR_CENTER_5_MISSING = -12;
-  private static final int ERROR_CENTER_6_MISSING = -13;
-  private static final int ERROR_CENTER_7_MISSING = -14;
-
-  private static final int ERROR_TWO_CORNERS      = -15;
-  private static final int ERROR_TWO_CENTERS      = -16;
-  private static final int ERROR_CORNER_TWIST_90  = -17;
-  private static final int ERROR_CORNER_TWIST_180 = -18;
-  private static final int ERROR_CORNERS_CANNOT   = -19;
+  private static final int ERROR_CORNER_MISSING   = -1;
+  private static final int ERROR_CENTER_MISSING   = -2;
+  private static final int ERROR_TWO_CORNERS      = -3;
+  private static final int ERROR_TWO_CENTERS      = -4;
+  private static final int ERROR_CORNER_TWIST_90  = -5;
+  private static final int ERROR_CORNER_TWIST_180 = -6;
+  private static final int ERROR_CORNERS_CANNOT   = -7;
 
   private final int[] mFaceColors;
-
+  private int mErrColor1, mErrColor2;
   private static final int[] FREE_CENTERS = {0,2,5,7};
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -148,16 +134,12 @@ public class SolverTablebaseDIAM2 extends SolverTablebase
       if( t==1 || t==3 ) return ERROR_CORNER_TWIST_90;
       if( t==2 )
         {
-        if( i<5 )
-          {
-          total+=(1<<i);
-          even = !even;
-          }
-        else if( even ) return ERROR_CORNER_TWIST_180;
+        if( i<5 ) total+=(1<<i);
+        even = !even;
         }
       }
 
-    return total;
+    return even ? total : ERROR_CORNER_TWIST_180;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -198,38 +180,38 @@ public class SolverTablebaseDIAM2 extends SolverTablebase
     output[6] = centers[6];
 
     int color01 = figureOutColor(corners,output[4],output[1]);
-    if( color01<0 ) return ERROR_CORNER_FR_MISSING;
+    if( color01<0 ) { mErrColor1=4; mErrColor2=1; return ERROR_CORNER_MISSING; }
     int color02 = figureOutColor(corners,output[3],output[4]);
-    if( color02<0 ) return ERROR_CORNER_FL_MISSING;
+    if( color02<0 ) { mErrColor1=3; mErrColor2=4; return ERROR_CORNER_MISSING; }
     int color03 = figureOutColor(corners,output[1],output[3]);
-    if( color03<0 ) return ERROR_CORNER_TO_MISSING;
+    if( color03<0 ) { mErrColor1=1; mErrColor2=3; return ERROR_CORNER_MISSING; }
     if( color01!=color02 || color01!=color03 ) return ERROR_CORNERS_CANNOT;
     output[0] = color01;
 
     int color21 = figureOutColor(corners,output[1],output[6]);
-    if( color21<0 ) return ERROR_CORNER_BR_MISSING;
+    if( color21<0 ) { mErrColor1=1; mErrColor2=6; return ERROR_CORNER_MISSING; }
     int color22 = figureOutColor(corners,output[6],output[3]);
-    if( color22<0 ) return ERROR_CORNER_BL_MISSING;
+    if( color22<0 ) { mErrColor1=6; mErrColor2=3; return ERROR_CORNER_MISSING; }
     int color23 = figureOutColor(corners,output[3],output[1]);
-    if( color23<0 ) return ERROR_CORNER_TO_MISSING;
+    if( color23<0 ) { mErrColor1=3; mErrColor2=1; return ERROR_CORNER_MISSING; }
     if( color21!=color22 || color21!=color23 ) return ERROR_CORNERS_CANNOT;
     output[2] = color21;
 
     int color51 = figureOutColor(corners,output[1],output[4]);
-    if( color51<0 ) return ERROR_CORNER_FR_MISSING;
+    if( color51<0 ) { mErrColor1=1; mErrColor2=4; return ERROR_CORNER_MISSING; }
     int color52 = figureOutColor(corners,output[6],output[1]);
-    if( color52<0 ) return ERROR_CORNER_BR_MISSING;
+    if( color52<0 ) { mErrColor1=6; mErrColor2=1; return ERROR_CORNER_MISSING; }
     int color53 = figureOutColor(corners,output[4],output[6]);
-    if( color53<0 ) return ERROR_CORNER_BO_MISSING;
+    if( color53<0 ) { mErrColor1=4; mErrColor2=6; return ERROR_CORNER_MISSING; }
     if( color51!=color52 || color51!=color53 ) return ERROR_CORNERS_CANNOT;
     output[5] = color51;
 
     int color71 = figureOutColor(corners,output[3],output[6]);
-    if( color71<0 ) return ERROR_CORNER_BL_MISSING;
+    if( color71<0 ) { mErrColor1=3; mErrColor2=6; return ERROR_CORNER_MISSING; }
     int color72 = figureOutColor(corners,output[4],output[3]);
-    if( color72<0 ) return ERROR_CORNER_FL_MISSING;
+    if( color72<0 ) { mErrColor1=4; mErrColor2=3; return ERROR_CORNER_MISSING; }
     int color73 = figureOutColor(corners,output[6],output[4]);
-    if( color73<0 ) return ERROR_CORNER_BO_MISSING;
+    if( color73<0 ) { mErrColor1=6; mErrColor2=4; return ERROR_CORNER_MISSING; }
     if( color71!=color72 || color71!=color73 ) return ERROR_CORNERS_CANNOT;
     output[7] = color71;
 
@@ -272,20 +254,7 @@ public class SolverTablebaseDIAM2 extends SolverTablebase
           break;
           }
 
-      if( !present )
-        {
-        switch(i)
-          {
-          case 0: return ERROR_CENTER_0_MISSING;
-          case 1: return ERROR_CENTER_1_MISSING;
-          case 2: return ERROR_CENTER_2_MISSING;
-          case 3: return ERROR_CENTER_3_MISSING;
-          case 4: return ERROR_CENTER_4_MISSING;
-          case 5: return ERROR_CENTER_5_MISSING;
-          case 6: return ERROR_CENTER_6_MISSING;
-          case 7: return ERROR_CENTER_7_MISSING;
-          }
-        }
+      if( !present ) { mErrColor1=i; return ERROR_CENTER_MISSING; }
       }
 
     return 0;
@@ -413,22 +382,8 @@ android.util.Log.e("D", "corn twist: "+corners_twist[0]+" "+corners_twist[1]+" "
     {
     switch(index)
       {
-      case ERROR_CORNER_FR_MISSING: return cornerError(res,1,4);
-      case ERROR_CORNER_BR_MISSING: return cornerError(res,1,6);
-      case ERROR_CORNER_BL_MISSING: return cornerError(res,3,6);
-      case ERROR_CORNER_FL_MISSING: return cornerError(res,3,4);
-      case ERROR_CORNER_TO_MISSING: return cornerError(res,1,3);
-      case ERROR_CORNER_BO_MISSING: return cornerError(res,4,6);
-
-      case ERROR_CENTER_0_MISSING : return centerError(res,0);
-      case ERROR_CENTER_1_MISSING : return centerError(res,1);
-      case ERROR_CENTER_2_MISSING : return centerError(res,2);
-      case ERROR_CENTER_3_MISSING : return centerError(res,3);
-      case ERROR_CENTER_4_MISSING : return centerError(res,4);
-      case ERROR_CENTER_5_MISSING : return centerError(res,5);
-      case ERROR_CENTER_6_MISSING : return centerError(res,6);
-      case ERROR_CENTER_7_MISSING : return centerError(res,7);
-
+      case ERROR_CORNER_MISSING   : return cornerError(res,mErrColor1,mErrColor2);
+      case ERROR_CENTER_MISSING   : return centerError(res,mErrColor1);
       case ERROR_TWO_CORNERS      : return res.getString(R.string.solver_generic_two_corners);
       case ERROR_TWO_CENTERS      : return res.getString(R.string.solver_generic_two_centers);
       case ERROR_CORNER_TWIST_90  : return res.getString(R.string.solver_generic_corner_twist) + " (90)";
diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseIVY2.java b/src/main/java/org/distorted/solvers/SolverTablebaseIVY2.java
index 8c4c8ed5..b0075323 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseIVY2.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseIVY2.java
@@ -20,14 +20,11 @@ import org.distorted.objectlib.tablebases.TablebaseHelpers;
 
 public class SolverTablebaseIVY2 extends SolverTablebase
 {
-  private static final int ERROR_CENTER_O_MISSING = -1;
-  private static final int ERROR_CENTER_W_MISSING = -2;
-  private static final int ERROR_CENTER_G_MISSING = -3;
-  private static final int ERROR_CENTER_Y_MISSING = -4;
-  private static final int ERROR_CENTER_B_MISSING = -5;
-  private static final int ERROR_CENTER_R_MISSING = -6;
-  private static final int ERROR_TWO_CENTERS_SWAP = -7;
-  private static final int ERROR_CORNERS_CANNOT   = -8;
+  private static final int ERROR_CENTER_MISSING   = -1;
+  private static final int ERROR_TWO_CENTERS_SWAP = -2;
+  private static final int ERROR_CORNERS_CANNOT   = -3;
+
+  private int mErrorColor;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -47,18 +44,7 @@ public class SolverTablebaseIVY2 extends SolverTablebase
           break;
           }
 
-      if( error )
-        {
-        switch(color)
-          {
-          case 0: return ERROR_CENTER_Y_MISSING;
-          case 1: return ERROR_CENTER_W_MISSING;
-          case 2: return ERROR_CENTER_B_MISSING;
-          case 3: return ERROR_CENTER_G_MISSING;
-          case 4: return ERROR_CENTER_R_MISSING;
-          case 5: return ERROR_CENTER_O_MISSING;
-          }
-        }
+      if( error ) { mErrorColor=color; return ERROR_CENTER_MISSING; }
       }
 
     return 0;
@@ -209,26 +195,24 @@ public class SolverTablebaseIVY2 extends SolverTablebase
     return perm_num + 360*(twist[0]+ 3*(twist[1]+ 3*(twist[2]+ 3*twist[3])));
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private String centerError(Resources res, int face)
+    {
+    int j = getHexColor(face,2);
+    String c = res.getString(j);
+    return res.getString(R.string.solver_generic_missing_center,c);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public String error(int index, Resources res)
     {
     switch(index)
       {
-      case ERROR_CENTER_W_MISSING  : String colorW = res.getString(R.string.color_white2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorW);
-      case ERROR_CENTER_O_MISSING  : String colorO = res.getString(R.string.color_orange2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorO);
-      case ERROR_CENTER_G_MISSING  : String colorG = res.getString(R.string.color_green2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorG);
-      case ERROR_CENTER_Y_MISSING  : String colorY = res.getString(R.string.color_yellow2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorY);
-      case ERROR_CENTER_B_MISSING  : String colorB = res.getString(R.string.color_blue2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorB);
-      case ERROR_CENTER_R_MISSING  : String colorR = res.getString(R.string.color_red2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorR);
-      case ERROR_TWO_CENTERS_SWAP  : return res.getString(R.string.solver_generic_two_centers);
-      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_CENTER_MISSING  : return centerError(res,mErrorColor);
+      case ERROR_TWO_CENTERS_SWAP: return res.getString(R.string.solver_generic_two_centers);
+      case ERROR_CORNERS_CANNOT  : return res.getString(R.string.solver_generic_corners_cannot);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseJING2.java b/src/main/java/org/distorted/solvers/SolverTablebaseJING2.java
index d8681b15..38c3afcb 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseJING2.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseJING2.java
@@ -21,30 +21,17 @@ import org.distorted.objectlib.tablebases.TablebaseHelpers;
 
 public class SolverTablebaseJING2 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_GYB_MISSING = -1;
-  private static final int ERROR_CORNER_GYR_MISSING = -2;
-  private static final int ERROR_CORNER_GBR_MISSING = -3;
-  private static final int ERROR_CORNER_YBR_MISSING = -4;
-
-  private static final int ERROR_EDGE_RB_MISSING    = -5;
-  private static final int ERROR_EDGE_RY_MISSING    = -6;
-  private static final int ERROR_EDGE_RG_MISSING    = -7;
-  private static final int ERROR_EDGE_YB_MISSING    = -8;
-  private static final int ERROR_EDGE_GB_MISSING    = -9;
-  private static final int ERROR_EDGE_GY_MISSING    = -10;
-
-  private static final int ERROR_CENTER_G_MISSING   = -11;
-  private static final int ERROR_CENTER_Y_MISSING   = -12;
-  private static final int ERROR_CENTER_B_MISSING   = -13;
-  private static final int ERROR_CENTER_R_MISSING   = -14;
-
-  private static final int ERROR_CORNERS_CANNOT     = -15;
-  private static final int ERROR_EDGE_TWISTED       = -16;
-  private static final int ERROR_CORNER_TWISTED     = -17;
-  private static final int ERROR_TWO_EDGES          = -18;
-  private static final int ERROR_TWO_CENTERS        = -19;
+  private static final int ERROR_CORNER_MISSING = -1;
+  private static final int ERROR_EDGE_MISSING   = -2;
+  private static final int ERROR_CENTER_MISSING = -3;
+  private static final int ERROR_CORNERS_CANNOT = -4;
+  private static final int ERROR_EDGE_TWISTED   = -5;
+  private static final int ERROR_CORNER_TWISTED = -6;
+  private static final int ERROR_TWO_EDGES      = -7;
+  private static final int ERROR_TWO_CENTERS    = -8;
 
   private int[] mFaceColors;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -90,10 +77,10 @@ public class SolverTablebaseJING2 extends SolverTablebase
       if( pieceEqual3(corners[i],1,2,3) ) ybr = true;
       }
 
-    if( !ybr ) return ERROR_CORNER_YBR_MISSING;
-    if( !gbr ) return ERROR_CORNER_GBR_MISSING;
-    if( !gyr ) return ERROR_CORNER_GYR_MISSING;
-    if( !gyb ) return ERROR_CORNER_GYB_MISSING;
+    if( !ybr ) { mErrColor1=1; mErrColor2=2; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gbr ) { mErrColor1=0; mErrColor2=2; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gyr ) { mErrColor1=0; mErrColor2=1; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gyb ) { mErrColor1=0; mErrColor2=1; mErrColor3=2; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -107,18 +94,18 @@ public class SolverTablebaseJING2 extends SolverTablebase
 
     for(int i=0; i<6; i++)
       for(int j=0; j<6; j++)
-        if (pieceEqual2(edges[i], edgeColors[j]))
+        if( pieceEqual2(edges[i], edgeColors[j]) )
           {
           present[j] = true;
           break;
           }
 
-    if( !present[0] ) return ERROR_EDGE_RB_MISSING;
-    if( !present[1] ) return ERROR_EDGE_GB_MISSING;
-    if( !present[2] ) return ERROR_EDGE_RG_MISSING;
-    if( !present[3] ) return ERROR_EDGE_YB_MISSING;
-    if( !present[4] ) return ERROR_EDGE_RY_MISSING;
-    if( !present[5] ) return ERROR_EDGE_GY_MISSING;
+    if( !present[0] ) { mErrColor1=3; mErrColor2=2; return ERROR_EDGE_MISSING; }
+    if( !present[1] ) { mErrColor1=3; mErrColor2=1; return ERROR_EDGE_MISSING; }
+    if( !present[2] ) { mErrColor1=2; mErrColor2=1; return ERROR_EDGE_MISSING; }
+    if( !present[3] ) { mErrColor1=3; mErrColor2=0; return ERROR_EDGE_MISSING; }
+    if( !present[4] ) { mErrColor1=2; mErrColor2=0; return ERROR_EDGE_MISSING; }
+    if( !present[5] ) { mErrColor1=1; mErrColor2=0; return ERROR_EDGE_MISSING; }
 
     return 0;
     }
@@ -129,16 +116,12 @@ public class SolverTablebaseJING2 extends SolverTablebase
     {
     boolean[] present = new boolean[4];
     for(int i=0; i<4; i++) present[i] = false;
+    for(int i=0; i<4; i++) present[centers[i]]= true;
 
-    for(int i=0; i<4; i++)
-      {
-      present[centers[i]]= true;
-      }
-
-    if( !present[0] ) return ERROR_CENTER_G_MISSING;
-    if( !present[1] ) return ERROR_CENTER_Y_MISSING;
-    if( !present[2] ) return ERROR_CENTER_B_MISSING;
-    if( !present[3] ) return ERROR_CENTER_R_MISSING;
+    if( !present[0] ) { mErrColor1=0; return ERROR_CENTER_MISSING; }
+    if( !present[1] ) { mErrColor1=1; return ERROR_CENTER_MISSING; }
+    if( !present[2] ) { mErrColor1=2; return ERROR_CENTER_MISSING; }
+    if( !present[3] ) { mErrColor1=3; return ERROR_CENTER_MISSING; }
 
     return 0;
     }
@@ -423,35 +406,29 @@ public class SolverTablebaseJING2 extends SolverTablebase
     return res.getString(R.string.solver_generic_missing_edge,c0,c1);
     }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private String centerError(Resources res, int face)
+    {
+    int j = getTetColor(face,2);
+    String c = res.getString(j);
+    return res.getString(R.string.solver_generic_missing_center,c);
+    }
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public String error(int index, Resources res)
     {
     switch(index)
       {
-      case ERROR_CORNER_YBR_MISSING: return cornerError(res,3,2,1);
-      case ERROR_CORNER_GBR_MISSING: return cornerError(res,3,2,0);
-      case ERROR_CORNER_GYR_MISSING: return cornerError(res,3,1,0);
-      case ERROR_CORNER_GYB_MISSING: return cornerError(res,2,1,0);
-      case ERROR_EDGE_RB_MISSING   : return edgeError(res,3,2);
-      case ERROR_EDGE_RY_MISSING   : return edgeError(res,2,0);
-      case ERROR_EDGE_RG_MISSING   : return edgeError(res,2,1);
-      case ERROR_EDGE_YB_MISSING   : return edgeError(res,3,0);
-      case ERROR_EDGE_GB_MISSING   : return edgeError(res,3,1);
-      case ERROR_EDGE_GY_MISSING   : return edgeError(res,1,0);
-      case ERROR_CENTER_G_MISSING  : String colorG = res.getString(R.string.color_green2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorG);
-      case ERROR_CENTER_Y_MISSING  : String colorY = res.getString(R.string.color_yellow2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorY);
-      case ERROR_CENTER_B_MISSING  : String colorB = res.getString(R.string.color_blue2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorB);
-      case ERROR_CENTER_R_MISSING  : String colorR = res.getString(R.string.color_red2);
-                                     return res.getString(R.string.solver_generic_missing_center,colorR);
-      case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);
-      case ERROR_EDGE_TWISTED      : return res.getString(R.string.solver_generic_edge_twist);
-      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
-      case ERROR_TWO_EDGES         : return res.getString(R.string.solver_generic_two_edges);
-      case ERROR_TWO_CENTERS       : return res.getString(R.string.solver_generic_two_centers);
+      case ERROR_CORNER_MISSING: return cornerError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_EDGE_MISSING  : return edgeError(res,mErrColor1,mErrColor2);
+      case ERROR_CENTER_MISSING: return centerError(res,mErrColor1);
+      case ERROR_CORNER_TWISTED: return res.getString(R.string.solver_generic_corner_twist);
+      case ERROR_EDGE_TWISTED  : return res.getString(R.string.solver_generic_edge_twist);
+      case ERROR_CORNERS_CANNOT: return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_TWO_EDGES     : return res.getString(R.string.solver_generic_two_edges);
+      case ERROR_TWO_CENTERS   : return res.getString(R.string.solver_generic_two_centers);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebasePDIA3.java b/src/main/java/org/distorted/solvers/SolverTablebasePDIA3.java
index 4605e0aa..651361ad 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebasePDIA3.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebasePDIA3.java
@@ -20,26 +20,12 @@ import org.distorted.objectlib.tablebases.TablebaseHelpers;
 
 public class SolverTablebasePDIA3 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_FR_MISSING = -1;
-  private static final int ERROR_CORNER_BR_MISSING = -2;
-  private static final int ERROR_CORNER_BL_MISSING = -3;
-  private static final int ERROR_CORNER_FL_MISSING = -4;
-  private static final int ERROR_CORNER_TO_MISSING = -5;
-  private static final int ERROR_CORNER_BO_MISSING = -6;
-
-  private static final int ERROR_CENTER_0_MISSING = -7;
-  private static final int ERROR_CENTER_1_MISSING = -8;
-  private static final int ERROR_CENTER_2_MISSING = -9;
-  private static final int ERROR_CENTER_3_MISSING = -10;
-  private static final int ERROR_CENTER_4_MISSING = -11;
-  private static final int ERROR_CENTER_5_MISSING = -12;
-  private static final int ERROR_CENTER_6_MISSING = -13;
-  private static final int ERROR_CENTER_7_MISSING = -14;
-
-  private static final int ERROR_TWO_CENTERS      = -15;
-  private static final int ERROR_CORNERS_CANNOT   = -16;
+  private static final int ERROR_CENTER_MISSING = -1;
+  private static final int ERROR_TWO_CENTERS    = -2;
+  private static final int ERROR_CORNERS_CANNOT = -3;
 
   private final int[] mFaceColors;
+  private int mErrColor;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -144,20 +130,7 @@ public class SolverTablebasePDIA3 extends SolverTablebase
           break;
           }
 
-      if( !present )
-        {
-        switch(i)
-          {
-          case 0: return ERROR_CENTER_0_MISSING;
-          case 1: return ERROR_CENTER_1_MISSING;
-          case 2: return ERROR_CENTER_2_MISSING;
-          case 3: return ERROR_CENTER_3_MISSING;
-          case 4: return ERROR_CENTER_4_MISSING;
-          case 5: return ERROR_CENTER_5_MISSING;
-          case 6: return ERROR_CENTER_6_MISSING;
-          case 7: return ERROR_CENTER_7_MISSING;
-          }
-        }
+      if( !present ) { mErrColor=i; return ERROR_CENTER_MISSING; }
       }
 
     return 0;
@@ -262,41 +235,15 @@ android.util.Log.e("D", "ret="+(total_twist + 2048*centers_perm_num) );
     return res.getString(R.string.solver_generic_missing_center,color);
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  private String cornerError(Resources res, int f1, int f2)
-    {
-    int i1 = getOctColor(f1,3);
-    int i2 = getOctColor(f2,4);
-    String c1 = res.getString(i1);
-    String c2 = res.getString(i2);
-    return res.getString(R.string.solver_generic_missing_corner2,c1,c2);
-    }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   public String error(int index, Resources res)
     {
     switch(index)
       {
-      case ERROR_CORNER_FR_MISSING: return cornerError(res,1,4);
-      case ERROR_CORNER_BR_MISSING: return cornerError(res,1,6);
-      case ERROR_CORNER_BL_MISSING: return cornerError(res,3,6);
-      case ERROR_CORNER_FL_MISSING: return cornerError(res,3,4);
-      case ERROR_CORNER_TO_MISSING: return cornerError(res,1,3);
-      case ERROR_CORNER_BO_MISSING: return cornerError(res,4,6);
-
-      case ERROR_CENTER_0_MISSING : return centerError(res,0);
-      case ERROR_CENTER_1_MISSING : return centerError(res,1);
-      case ERROR_CENTER_2_MISSING : return centerError(res,2);
-      case ERROR_CENTER_3_MISSING : return centerError(res,3);
-      case ERROR_CENTER_4_MISSING : return centerError(res,4);
-      case ERROR_CENTER_5_MISSING : return centerError(res,5);
-      case ERROR_CENTER_6_MISSING : return centerError(res,6);
-      case ERROR_CENTER_7_MISSING : return centerError(res,7);
-
-      case ERROR_TWO_CENTERS      : return res.getString(R.string.solver_generic_two_centers);
-      case ERROR_CORNERS_CANNOT   : return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_CENTER_MISSING : return centerError(res,mErrColor);
+      case ERROR_TWO_CENTERS    : return res.getString(R.string.solver_generic_two_centers);
+      case ERROR_CORNERS_CANNOT : return res.getString(R.string.solver_generic_corners_cannot);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebasePDUO2.java b/src/main/java/org/distorted/solvers/SolverTablebasePDUO2.java
index 08c13c16..9a731e1b 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebasePDUO2.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebasePDUO2.java
@@ -19,20 +19,13 @@ import org.distorted.objectlib.main.TwistyObject;
 
 public class SolverTablebasePDUO2 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_GYB_MISSING = -1;
-  private static final int ERROR_CORNER_GYR_MISSING = -2;
-  private static final int ERROR_CORNER_GBR_MISSING = -3;
-  private static final int ERROR_CORNER_YBR_MISSING = -4;
+  private static final int ERROR_CORNER_MISSING = -1;
+  private static final int ERROR_CENTER_MISSING = -2;
+  private static final int ERROR_TWO_CENTERS    = -3;
+  private static final int ERROR_CORNER_TWISTED = -4;
+  private static final int ERROR_CORNERS_CANNOT = -5;
 
-  private static final int ERROR_CENTER_G_MISSING = -5;
-  private static final int ERROR_CENTER_Y_MISSING = -6;
-  private static final int ERROR_CENTER_B_MISSING = -7;
-  private static final int ERROR_CENTER_R_MISSING = -8;
-
-  private static final int ERROR_TWO_CENTERS      = -9;
-  private static final int ERROR_CORNER_TWISTED   = -10;
-
-  private static final int ERROR_CORNERS_CANNOT   = -11;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -63,10 +56,10 @@ public class SolverTablebasePDUO2 extends SolverTablebase
       if( cornerEqual(corners[i],1,2,3) ) ybr = true;
       }
 
-    if( !ybr ) return ERROR_CORNER_YBR_MISSING;
-    if( !gbr ) return ERROR_CORNER_GBR_MISSING;
-    if( !gyr ) return ERROR_CORNER_GYR_MISSING;
-    if( !gyb ) return ERROR_CORNER_GYB_MISSING;
+    if( !ybr ) { mErrColor1=1; mErrColor2=2; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gbr ) { mErrColor1=0; mErrColor2=2; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gyr ) { mErrColor1=0; mErrColor2=1; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gyb ) { mErrColor1=0; mErrColor2=1; mErrColor3=2; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -75,10 +68,9 @@ public class SolverTablebasePDUO2 extends SolverTablebase
 
   private int checkAllCentersPresent(int[] centers)
     {
-    if( centers[0]!=0 && centers[1]!=0 && centers[2]!=0 && centers[3]!=0 ) return ERROR_CENTER_G_MISSING;
-    if( centers[0]!=1 && centers[1]!=1 && centers[2]!=1 && centers[3]!=1 ) return ERROR_CENTER_Y_MISSING;
-    if( centers[0]!=2 && centers[1]!=2 && centers[2]!=2 && centers[3]!=2 ) return ERROR_CENTER_B_MISSING;
-    if( centers[0]!=3 && centers[1]!=3 && centers[2]!=3 && centers[3]!=3 ) return ERROR_CENTER_R_MISSING;
+    for(int i=0; i<4; i++)
+      if( centers[0]!=i && centers[1]!=i && centers[2]!=i && centers[3]!=i )
+        { mErrColor1=i; return ERROR_CENTER_MISSING; }
 
     return 0;
     }
@@ -271,17 +263,11 @@ public class SolverTablebasePDUO2 extends SolverTablebase
     {
     switch(index)
       {
-      case ERROR_CORNER_YBR_MISSING: return cornerError(res,3,2,1);
-      case ERROR_CORNER_GBR_MISSING: return cornerError(res,3,2,0);
-      case ERROR_CORNER_GYR_MISSING: return cornerError(res,3,1,0);
-      case ERROR_CORNER_GYB_MISSING: return cornerError(res,2,1,0);
-      case ERROR_CENTER_G_MISSING  : return centerError(res,0);
-      case ERROR_CENTER_Y_MISSING  : return centerError(res,1);
-      case ERROR_CENTER_B_MISSING  : return centerError(res,2);
-      case ERROR_CENTER_R_MISSING  : return centerError(res,3);
-      case ERROR_TWO_CENTERS       : return res.getString(R.string.solver_generic_two_centers);
-      case ERROR_CORNER_TWISTED    : return res.getString(R.string.solver_generic_corner_twist);
-      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_CORNER_MISSING: return cornerError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_CENTER_MISSING: return centerError(res,mErrColor1);
+      case ERROR_TWO_CENTERS   : return res.getString(R.string.solver_generic_two_centers);
+      case ERROR_CORNER_TWISTED: return res.getString(R.string.solver_generic_corner_twist);
+      case ERROR_CORNERS_CANNOT: return res.getString(R.string.solver_generic_corners_cannot);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebasePYRA3.java b/src/main/java/org/distorted/solvers/SolverTablebasePYRA3.java
index 31600bc6..1e38a925 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebasePYRA3.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebasePYRA3.java
@@ -21,31 +21,18 @@ import org.distorted.objectlib.tablebases.TBPyraminx;
 
 public class SolverTablebasePYRA3 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_GYB_MISSING = -1;
-  private static final int ERROR_CORNER_GYR_MISSING = -2;
-  private static final int ERROR_CORNER_GBR_MISSING = -3;
-  private static final int ERROR_CORNER_YBR_MISSING = -4;
-
-  private static final int ERROR_VERTEX_GYB_MISSING = -5;
-  private static final int ERROR_VERTEX_GYR_MISSING = -6;
-  private static final int ERROR_VERTEX_GBR_MISSING = -7;
-  private static final int ERROR_VERTEX_YBR_MISSING = -8;
-
-  private static final int ERROR_EDGE_RB_MISSING = -9;
-  private static final int ERROR_EDGE_RY_MISSING = -10;
-  private static final int ERROR_EDGE_RG_MISSING = -11;
-  private static final int ERROR_EDGE_YB_MISSING = -12;
-  private static final int ERROR_EDGE_GB_MISSING = -13;
-  private static final int ERROR_EDGE_GY_MISSING = -14;
-
-  private static final int ERROR_CORNERS_CANNOT   = -15;
-  private static final int ERROR_VERTICES_CANNOT  = -16;
-  private static final int ERROR_EDGE_TWISTED     = -17;
-  private static final int ERROR_C_V_DONT_MATCH   = -18;
-  private static final int ERROR_TWO_EDGES        = -19;
+  private static final int ERROR_CORNER_MISSING = -1;
+  private static final int ERROR_VERTEX_MISSING = -2;
+  private static final int ERROR_EDGE_MISSING   = -3;
+  private static final int ERROR_CORNERS_CANNOT = -4;
+  private static final int ERROR_VERTICES_CANNOT= -5;
+  private static final int ERROR_EDGE_TWISTED   = -6;
+  private static final int ERROR_C_V_DONT_MATCH = -7;
+  private static final int ERROR_TWO_EDGES      = -8;
 
   private int[] mCornerTwist;
   private int[] mFaceColors;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -84,10 +71,10 @@ public class SolverTablebasePYRA3 extends SolverTablebase
       if( pieceEqual3(corners[i],1,2,3) ) ybr = true;
       }
 
-    if( !ybr ) return ERROR_CORNER_YBR_MISSING;
-    if( !gbr ) return ERROR_CORNER_GBR_MISSING;
-    if( !gyr ) return ERROR_CORNER_GYR_MISSING;
-    if( !gyb ) return ERROR_CORNER_GYB_MISSING;
+    if( !ybr ) { mErrColor1=1; mErrColor2=2; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gbr ) { mErrColor1=0; mErrColor2=2; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gyr ) { mErrColor1=0; mErrColor2=1; mErrColor3=3; return ERROR_CORNER_MISSING; }
+    if( !gyb ) { mErrColor1=0; mErrColor2=1; mErrColor3=2; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -109,10 +96,10 @@ public class SolverTablebasePYRA3 extends SolverTablebase
       if( pieceEqual3(vertex[i],1,2,3) ) ybr = true;
       }
 
-    if( !ybr ) return ERROR_VERTEX_YBR_MISSING;
-    if( !gbr ) return ERROR_VERTEX_GBR_MISSING;
-    if( !gyr ) return ERROR_VERTEX_GYR_MISSING;
-    if( !gyb ) return ERROR_VERTEX_GYB_MISSING;
+    if( !ybr ) { mErrColor1=1; mErrColor2=2; mErrColor3=3; return ERROR_VERTEX_MISSING; }
+    if( !gbr ) { mErrColor1=0; mErrColor2=2; mErrColor3=3; return ERROR_VERTEX_MISSING; }
+    if( !gyr ) { mErrColor1=0; mErrColor2=1; mErrColor3=3; return ERROR_VERTEX_MISSING; }
+    if( !gyb ) { mErrColor1=0; mErrColor2=1; mErrColor3=2; return ERROR_VERTEX_MISSING; }
 
     return 0;
     }
@@ -126,18 +113,18 @@ public class SolverTablebasePYRA3 extends SolverTablebase
 
     for(int i=0; i<6; i++)
       for(int j=0; j<6; j++)
-        if (pieceEqual2(edges[i], edgeColors[j]))
+        if( pieceEqual2(edges[i], edgeColors[j]) )
           {
           present[j] = true;
           break;
           }
 
-    if( !present[0] ) return ERROR_EDGE_RB_MISSING;
-    if( !present[1] ) return ERROR_EDGE_RY_MISSING;
-    if( !present[2] ) return ERROR_EDGE_RG_MISSING;
-    if( !present[3] ) return ERROR_EDGE_YB_MISSING;
-    if( !present[4] ) return ERROR_EDGE_GB_MISSING;
-    if( !present[5] ) return ERROR_EDGE_GY_MISSING;
+    if( !present[0] ) { mErrColor1=3; mErrColor2=2; return ERROR_EDGE_MISSING; }
+    if( !present[1] ) { mErrColor1=2; mErrColor2=0; return ERROR_EDGE_MISSING; }
+    if( !present[2] ) { mErrColor1=2; mErrColor2=1; return ERROR_EDGE_MISSING; }
+    if( !present[3] ) { mErrColor1=3; mErrColor2=0; return ERROR_EDGE_MISSING; }
+    if( !present[4] ) { mErrColor1=3; mErrColor2=1; return ERROR_EDGE_MISSING; }
+    if( !present[5] ) { mErrColor1=1; mErrColor2=0; return ERROR_EDGE_MISSING; }
 
     return 0;
     }
@@ -446,25 +433,14 @@ public class SolverTablebasePYRA3 extends SolverTablebase
     {
     switch(index)
       {
-      case ERROR_CORNER_YBR_MISSING: return cornerError(res,3,2,1);
-      case ERROR_CORNER_GBR_MISSING: return cornerError(res,3,2,0);
-      case ERROR_CORNER_GYR_MISSING: return cornerError(res,3,1,0);
-      case ERROR_CORNER_GYB_MISSING: return cornerError(res,2,1,0);
-      case ERROR_VERTEX_YBR_MISSING: return vertexError(res,3,2,1);
-      case ERROR_VERTEX_GBR_MISSING: return vertexError(res,3,2,0);
-      case ERROR_VERTEX_GYR_MISSING: return vertexError(res,3,1,0);
-      case ERROR_VERTEX_GYB_MISSING: return vertexError(res,2,1,0);
-      case ERROR_EDGE_RB_MISSING   : return edgeError(res,3,2);
-      case ERROR_EDGE_RY_MISSING   : return edgeError(res,2,0);
-      case ERROR_EDGE_RG_MISSING   : return edgeError(res,2,1);
-      case ERROR_EDGE_YB_MISSING   : return edgeError(res,3,0);
-      case ERROR_EDGE_GB_MISSING   : return edgeError(res,3,1);
-      case ERROR_EDGE_GY_MISSING   : return edgeError(res,1,0);
-      case ERROR_EDGE_TWISTED      : return res.getString(R.string.solver_generic_edge_twist);
-      case ERROR_CORNERS_CANNOT    : return res.getString(R.string.solver_generic_corners_cannot);
-      case ERROR_VERTICES_CANNOT   : return res.getString(R.string.solver_generic_vertices_cannot);
-      case ERROR_C_V_DONT_MATCH    : return res.getString(R.string.solver_generic_c_v_dont_match);
-      case ERROR_TWO_EDGES         : return res.getString(R.string.solver_generic_two_edges);
+      case ERROR_CORNER_MISSING : return cornerError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_VERTEX_MISSING : return vertexError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_EDGE_MISSING   : return edgeError(res,mErrColor1,mErrColor2);
+      case ERROR_EDGE_TWISTED   : return res.getString(R.string.solver_generic_edge_twist);
+      case ERROR_CORNERS_CANNOT : return res.getString(R.string.solver_generic_corners_cannot);
+      case ERROR_VERTICES_CANNOT: return res.getString(R.string.solver_generic_vertices_cannot);
+      case ERROR_C_V_DONT_MATCH : return res.getString(R.string.solver_generic_c_v_dont_match);
+      case ERROR_TWO_EDGES      : return res.getString(R.string.solver_generic_two_edges);
       }
 
     return null;
diff --git a/src/main/java/org/distorted/solvers/SolverTablebaseSKEW2.java b/src/main/java/org/distorted/solvers/SolverTablebaseSKEW2.java
index d6f590fc..e8ded988 100644
--- a/src/main/java/org/distorted/solvers/SolverTablebaseSKEW2.java
+++ b/src/main/java/org/distorted/solvers/SolverTablebaseSKEW2.java
@@ -24,31 +24,17 @@ import org.distorted.objectlib.tablebases.TablebaseHelpers;
 
 public class SolverTablebaseSKEW2 extends SolverTablebase
 {
-  private static final int ERROR_CORNER_135_MISSING = -1;
-  private static final int ERROR_CORNER_134_MISSING = -2;
-  private static final int ERROR_CORNER_125_MISSING = -3;
-  private static final int ERROR_CORNER_124_MISSING = -4;
-  private static final int ERROR_CORNER_035_MISSING = -5;
-  private static final int ERROR_CORNER_034_MISSING = -6;
-  private static final int ERROR_CORNER_025_MISSING = -7;
-  private static final int ERROR_CORNER_024_MISSING = -8;
-
-  private static final int ERROR_CENTER_0_MISSING   = -9;
-  private static final int ERROR_CENTER_1_MISSING   = -10;
-  private static final int ERROR_CENTER_2_MISSING   = -11;
-  private static final int ERROR_CENTER_3_MISSING   = -12;
-  private static final int ERROR_CENTER_4_MISSING   = -13;
-  private static final int ERROR_CENTER_5_MISSING   = -14;
-
-  private static final int ERROR_CORNERS_CANNOT     = -15;
-  private static final int ERROR_CORNER_TWISTED     = -16;
-  private static final int ERROR_TWO_CENTERS        = -17;
-  private static final int ERROR_TWO_CORNERS        = -18;
-
-  private static final int ERROR_FREE_CORNERS_NOT_EVEN    = -19;
-  private static final int ERROR_FREE_CORNERS_ROTATED     = -20;
+  private static final int ERROR_CORNER_MISSING       = -1;
+  private static final int ERROR_CENTER_MISSING       = -2;
+  private static final int ERROR_CORNERS_CANNOT       = -3;
+  private static final int ERROR_CORNER_TWISTED       = -4;
+  private static final int ERROR_TWO_CENTERS          = -5;
+  private static final int ERROR_TWO_CORNERS          = -6;
+  private static final int ERROR_FREE_CORNERS_NOT_EVEN= -7;
+  private static final int ERROR_FREE_CORNERS_ROTATED = -8;
 
   private final int[] mFaceColors;
+  private int mErrColor1, mErrColor2, mErrColor3;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -100,12 +86,8 @@ public class SolverTablebaseSKEW2 extends SolverTablebase
       tmp[i] = color;
       }
 
-    if( !present[0] ) return ERROR_CENTER_0_MISSING;
-    if( !present[1] ) return ERROR_CENTER_1_MISSING;
-    if( !present[2] ) return ERROR_CENTER_2_MISSING;
-    if( !present[3] ) return ERROR_CENTER_3_MISSING;
-    if( !present[4] ) return ERROR_CENTER_4_MISSING;
-    if( !present[5] ) return ERROR_CENTER_5_MISSING;
+    for(int i=0; i<6; i++)
+      if( !present[i] ) { mErrColor1=i; return ERROR_CENTER_MISSING; }
 
     for(int i=0; i<6; i++) mcl[i] = map[mFaceColors[i]];
     createCenterPermutation(out,mcl,tmp);
@@ -179,14 +161,14 @@ public class SolverTablebaseSKEW2 extends SolverTablebase
       if( cornerIs(corners[i],1,3,5) ) present[7]=true;
       }
 
-    if( !present[0] ) return ERROR_CORNER_024_MISSING;
-    if( !present[1] ) return ERROR_CORNER_025_MISSING;
-    if( !present[2] ) return ERROR_CORNER_034_MISSING;
-    if( !present[3] ) return ERROR_CORNER_035_MISSING;
-    if( !present[4] ) return ERROR_CORNER_124_MISSING;
-    if( !present[5] ) return ERROR_CORNER_125_MISSING;
-    if( !present[6] ) return ERROR_CORNER_134_MISSING;
-    if( !present[7] ) return ERROR_CORNER_135_MISSING;
+    if( !present[0] ) { mErrColor1=0; mErrColor2=2; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( !present[1] ) { mErrColor1=0; mErrColor2=2; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( !present[2] ) { mErrColor1=0; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( !present[3] ) { mErrColor1=0; mErrColor2=3; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( !present[4] ) { mErrColor1=1; mErrColor2=2; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( !present[5] ) { mErrColor1=1; mErrColor2=2; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( !present[6] ) { mErrColor1=1; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( !present[7] ) { mErrColor1=1; mErrColor2=3; mErrColor3=5; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -210,10 +192,10 @@ public class SolverTablebaseSKEW2 extends SolverTablebase
       if( cornerIs(cor,1,3,5) ) perm[3] = i;
       }
 
-    if( perm[0]==-1 ) return ERROR_CORNER_025_MISSING;
-    if( perm[1]==-1 ) return ERROR_CORNER_034_MISSING;
-    if( perm[2]==-1 ) return ERROR_CORNER_124_MISSING;
-    if( perm[3]==-1 ) return ERROR_CORNER_135_MISSING;
+    if( perm[0]==-1 ) { mErrColor1=0; mErrColor2=2; mErrColor3=5; return ERROR_CORNER_MISSING; }
+    if( perm[1]==-1 ) { mErrColor1=0; mErrColor2=3; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( perm[2]==-1 ) { mErrColor1=1; mErrColor2=2; mErrColor3=4; return ERROR_CORNER_MISSING; }
+    if( perm[3]==-1 ) { mErrColor1=1; mErrColor2=3; mErrColor3=5; return ERROR_CORNER_MISSING; }
 
     return 0;
     }
@@ -353,20 +335,8 @@ public class SolverTablebaseSKEW2 extends SolverTablebase
     {
     switch(index)
       {
-      case ERROR_CORNER_135_MISSING   : return cornerError(res,1,3,5);
-      case ERROR_CORNER_134_MISSING   : return cornerError(res,1,3,4);
-      case ERROR_CORNER_125_MISSING   : return cornerError(res,1,2,5);
-      case ERROR_CORNER_124_MISSING   : return cornerError(res,1,2,4);
-      case ERROR_CORNER_035_MISSING   : return cornerError(res,0,3,5);
-      case ERROR_CORNER_034_MISSING   : return cornerError(res,0,3,4);
-      case ERROR_CORNER_025_MISSING   : return cornerError(res,0,2,5);
-      case ERROR_CORNER_024_MISSING   : return cornerError(res,0,2,4);
-      case ERROR_CENTER_0_MISSING     : return centerError(res,0);
-      case ERROR_CENTER_1_MISSING     : return centerError(res,1);
-      case ERROR_CENTER_2_MISSING     : return centerError(res,2);
-      case ERROR_CENTER_3_MISSING     : return centerError(res,3);
-      case ERROR_CENTER_4_MISSING     : return centerError(res,4);
-      case ERROR_CENTER_5_MISSING     : return centerError(res,5);
+      case ERROR_CORNER_MISSING       : return cornerError(res,mErrColor1,mErrColor2,mErrColor3);
+      case ERROR_CENTER_MISSING       : return centerError(res,mErrColor1);
       case ERROR_CORNERS_CANNOT       : return res.getString(R.string.solver_generic_corners_cannot);
       case ERROR_CORNER_TWISTED       : return res.getString(R.string.solver_generic_corner_twist);
       case ERROR_TWO_CENTERS          : return res.getString(R.string.solver_generic_two_centers);