commit d5380277dac0d19c9b1bd50f65ac9a8c9e1777f9
Author: Leszek Koltunski <leszek@koltunski.pl>
Date:   Tue Sep 7 02:06:31 2021 +0200

    Remove statics from the Square classes.

diff --git a/src/main/java/org/distorted/objects/TwistySquare.java b/src/main/java/org/distorted/objects/TwistySquare.java
index cc0507c6..fccfb04b 100644
--- a/src/main/java/org/distorted/objects/TwistySquare.java
+++ b/src/main/java/org/distorted/objects/TwistySquare.java
@@ -51,8 +51,6 @@ abstract class TwistySquare extends TwistyObject
       new Static3D(0,-1,0),
     };
 
-  static final int[] BASIC_ANGLE = new int[] { 12,2,12 };
-
   static final int[] FACE_COLORS = new int[]
     {
       COLOR_YELLOW, COLOR_WHITE,
@@ -60,8 +58,25 @@ abstract class TwistySquare extends TwistyObject
       COLOR_RED   , COLOR_ORANGE
     };
 
-  static final Static4D[] QUATS = new Static4D[]
+  int mLastRot;
+  int[] mBasicAngle;
+  Static4D[] mQuats;
+  int[][] mQuatMult;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  TwistySquare(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
+               DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth)
     {
+    super(size, size, quat, texture, mesh, effects, moves, obj, res, scrWidth);
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  void initializeQuats()
+    {
+    mQuats = new Static4D[]
+      {
       new Static4D(  0.0f,  0.0f,  0.0f,  1.0f ),
       new Static4D(  0.0f, SIN15,  0.0f, COS15 ),
       new Static4D(  0.0f,  0.5f,  0.0f, SQ3/2 ),
@@ -87,93 +102,57 @@ abstract class TwistySquare extends TwistyObject
       new Static4D(-SQ2/2,  0.0f, SQ2/2,  0.0f ),
       new Static4D(-SQ3/2,  0.0f,  0.5f,  0.0f ),
       new Static4D(-COS15,  0.0f, SIN15,  0.0f )
-    };
-
-  static final double[][] VERTICES_MIDDLE = new double[][]
-    {
-      { -1.5-X, 0.5, 1.5 },
-      {    0.0, 0.5, 1.5 },
-      {    0.0, 0.5,-1.5 },
-      { -1.5+X, 0.5,-1.5 },
-      { -1.5-X,-0.5, 1.5 },
-      {    0.0,-0.5, 1.5 },
-      {    0.0,-0.5,-1.5 },
-      { -1.5+X,-0.5,-1.5 }
-    };
-
-  static final int[][] VERT_INDEXES_MIDDLE = new int[][]
-    {
-      {0,1,2,3},   // counterclockwise!
-      {4,5,6,7},
-      {4,5,1,0},
-      {5,6,2,1},
-      {6,7,3,2},
-      {7,4,0,3}
-    };
-
-  static final double[][] VERTICES_EDGE = new double[][]
-    {
-      { -X, 0.5, 0.0 },
-      { +X, 0.5, 0.0 },
-      {0.0, 0.5,-1.5 },
-      { -X,-0.5, 0.0 },
-      { +X,-0.5, 0.0 },
-      {0.0,-0.5,-1.5 },
-    };
-
-  static final int[][] VERT_INDEXES_EDGE = new int[][]
-    {
-      {0,1,2},   // counterclockwise!
-      {3,4,5},
-      {3,4,1,0},
-      {4,5,2,1},
-      {5,3,0,2}
-    };
+      };
+    }
 
-  // QUATS[i]*QUATS[j] = QUATS[QUAT_MULT[i][j]]
-  static final int[][] QUAT_MULT = new int[][]
-    {
-      {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,},
-      {  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,  0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12,},
-      {  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,  0,  1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13,},
-      {  3,  4,  5,  6,  7,  8,  9, 10, 11,  0,  1,  2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14,},
-      {  4,  5,  6,  7,  8,  9, 10, 11,  0,  1,  2,  3, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15,},
-      {  5,  6,  7,  8,  9, 10, 11,  0,  1,  2,  3,  4, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16,},
-      {  6,  7,  8,  9, 10, 11,  0,  1,  2,  3,  4,  5, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17,},
-      {  7,  8,  9, 10, 11,  0,  1,  2,  3,  4,  5,  6, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18,},
-      {  8,  9, 10, 11,  0,  1,  2,  3,  4,  5,  6,  7, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19,},
-      {  9, 10, 11,  0,  1,  2,  3,  4,  5,  6,  7,  8, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20,},
-      { 10, 11,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,},
-      { 11,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,},
-      { 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13,  0, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,},
-      { 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,  1,  0, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,},
-      { 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15,  2,  1,  0, 11, 10,  9,  8,  7,  6,  5,  4,  3,},
-      { 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16,  3,  2,  1,  0, 11, 10,  9,  8,  7,  6,  5,  4,},
-      { 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17,  4,  3,  2,  1,  0, 11, 10,  9,  8,  7,  6,  5,},
-      { 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18,  5,  4,  3,  2,  1,  0, 11, 10,  9,  8,  7,  6,},
-      { 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19,  6,  5,  4,  3,  2,  1,  0, 11, 10,  9,  8,  7,},
-      { 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20,  7,  6,  5,  4,  3,  2,  1,  0, 11, 10,  9,  8,},
-      { 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21,  8,  7,  6,  5,  4,  3,  2,  1,  0, 11, 10,  9,},
-      { 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0, 11, 10,},
-      { 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0, 11,},
-      { 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,}
-    };
 
-  int mLastRot;
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// QUATS[i]*QUATS[j] = QUATS[QUAT_MULT[i][j]]
+
+  void initializeQuatMult()
+    {
+    mQuatMult = new int[][]
+      {
+        {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,},
+        {  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,  0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12,},
+        {  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,  0,  1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13,},
+        {  3,  4,  5,  6,  7,  8,  9, 10, 11,  0,  1,  2, 15, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14,},
+        {  4,  5,  6,  7,  8,  9, 10, 11,  0,  1,  2,  3, 16, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15,},
+        {  5,  6,  7,  8,  9, 10, 11,  0,  1,  2,  3,  4, 17, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16,},
+        {  6,  7,  8,  9, 10, 11,  0,  1,  2,  3,  4,  5, 18, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17,},
+        {  7,  8,  9, 10, 11,  0,  1,  2,  3,  4,  5,  6, 19, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18,},
+        {  8,  9, 10, 11,  0,  1,  2,  3,  4,  5,  6,  7, 20, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19,},
+        {  9, 10, 11,  0,  1,  2,  3,  4,  5,  6,  7,  8, 21, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20,},
+        { 10, 11,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 22, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,},
+        { 11,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 23, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,},
+        { 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13,  0, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,},
+        { 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14,  1,  0, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,},
+        { 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16, 15,  2,  1,  0, 11, 10,  9,  8,  7,  6,  5,  4,  3,},
+        { 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17, 16,  3,  2,  1,  0, 11, 10,  9,  8,  7,  6,  5,  4,},
+        { 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18, 17,  4,  3,  2,  1,  0, 11, 10,  9,  8,  7,  6,  5,},
+        { 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19, 18,  5,  4,  3,  2,  1,  0, 11, 10,  9,  8,  7,  6,},
+        { 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20, 19,  6,  5,  4,  3,  2,  1,  0, 11, 10,  9,  8,  7,},
+        { 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21, 20,  7,  6,  5,  4,  3,  2,  1,  0, 11, 10,  9,  8,},
+        { 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22, 21,  8,  7,  6,  5,  4,  3,  2,  1,  0, 11, 10,  9,},
+        { 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 22,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0, 11, 10,},
+        { 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 23, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0, 11,},
+        { 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,}
+      };
+    }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  TwistySquare(int size, Static4D quat, DistortedTexture texture, MeshSquare mesh,
-               DistortedEffects effects, int[][] moves, ObjectList obj, Resources res, int scrWidth)
+  void initializeBasicAngle()
     {
-    super(size, size, quat, texture, mesh, effects, moves, obj, res, scrWidth);
+    mBasicAngle = new int[] {12,2,12};
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   Static4D[] getQuats()
     {
-    return QUATS;
+    if( mQuats==null ) initializeQuats();
+    return mQuats;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -237,6 +216,7 @@ abstract class TwistySquare extends TwistyObject
 
   public int[] getBasicAngle()
     {
-    return BASIC_ANGLE;
+    if( mBasicAngle ==null ) initializeBasicAngle();
+    return mBasicAngle;
     }
 }
diff --git a/src/main/java/org/distorted/objects/TwistySquare1.java b/src/main/java/org/distorted/objects/TwistySquare1.java
index 675d6751..56aabc2f 100644
--- a/src/main/java/org/distorted/objects/TwistySquare1.java
+++ b/src/main/java/org/distorted/objects/TwistySquare1.java
@@ -35,134 +35,17 @@ import java.util.Random;
 
 class TwistySquare1 extends TwistySquare
 {
-  private static final int[] QUAT_NUMBER = new int[]
-    {
-      0, 6,
-      0, 9, 6, 3, 18, 15, 12, 21,
-      0, 9, 6, 3, 15, 12, 21, 18
-    };
-
-  // centers of the 2 middles + 8 edges + 8 corners
-  private static final float[][] CENTERS = new float[][]
-    {
-      { 1.5f, 0.0f, 0.0f },
-      {-1.5f, 0.0f, 0.0f },
-
-      { 0.0f, 1.0f, 1.5f },
-      { 1.5f, 1.0f, 0.0f },
-      { 0.0f, 1.0f,-1.5f },
-      {-1.5f, 1.0f, 0.0f },
-      { 0.0f,-1.0f, 1.5f },
-      { 1.5f,-1.0f, 0.0f },
-      { 0.0f,-1.0f,-1.5f },
-      {-1.5f,-1.0f, 0.0f },
-
-      { 1.0f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f },
-      { 1.0f, 1.0f,-2.0f, 2.0f, 1.0f,-1.0f },
-      {-1.0f, 1.0f,-2.0f,-2.0f, 1.0f,-1.0f },
-      {-1.0f, 1.0f, 2.0f,-2.0f, 1.0f, 1.0f },
-      { 1.0f,-1.0f, 2.0f, 2.0f,-1.0f, 1.0f },
-      { 1.0f,-1.0f,-2.0f, 2.0f,-1.0f,-1.0f },
-      {-1.0f,-1.0f,-2.0f,-2.0f,-1.0f,-1.0f },
-      {-1.0f,-1.0f, 2.0f,-2.0f,-1.0f, 1.0f }
-    };
-
-  private static final double[][] VERTICES_CORNER = new double[][]
-    {
-      { X-1.5, 0.5,  0.0 },
-      {   0.0, 0.5,  0.0 },
-      {   0.0, 0.5,X-1.5 },
-      {  -1.5, 0.5, -1.5 },
-      { X-1.5,-0.5,  0.0 },
-      {   0.0,-0.5,  0.0 },
-      {   0.0,-0.5,X-1.5 },
-      {  -1.5,-0.5, -1.5 }
-    };
-
-  private static final int[][] VERT_INDEXES_CORNER = new int[][]
-    {
-      {0,1,2,3},   // counterclockwise!
-      {4,5,6,7},
-      {4,5,1,0},
-      {5,6,2,1},
-      {7,4,0,3},
-      {6,7,3,2}
-    };
-
-  private static final float[][] STICKERS = new float[][]
-    {
-      { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front
-      { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right
-      { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back
-      { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top
-      { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face
-      { -0.2637079f, -0.38185397f, 0.38185397f, -0.38185397f, 0.38185397f, 0.2637079f, -0.5f, 0.5f } // corner top
-    };
-
-  private static final int NUM_STICKERS = STICKERS.length;
-
-  private static final int[][] mStickerType = new int[][]
-    {
-      {  NUM_STICKERS,NUM_STICKERS,0,           1,           2,NUM_STICKERS },
-      {             3,NUM_STICKERS,4,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },
-      {             5,NUM_STICKERS,2,           2,NUM_STICKERS,NUM_STICKERS }
-    };
-
-  // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5
-  private static final int[][] mStickerColor = new int[][]
-    {
-      { 0, 0, 4, 0, 5, 0 },
-      { 0, 0, 5, 1, 4, 0 },
-
-      { 2, 0, 4, 0, 0, 0 },
-      { 2, 0, 0, 0, 0, 0 },
-      { 2, 0, 5, 0, 0, 0 },
-      { 2, 0, 1, 0, 0, 0 },
-      { 3, 0, 4, 0, 0, 0 },
-      { 3, 0, 0, 0, 0, 0 },
-      { 3, 0, 5, 0, 0, 0 },
-      { 3, 0, 1, 0, 0, 0 },
-
-      { 2, 0, 4, 0, 0, 0 },
-      { 2, 0, 0, 5, 0, 0 },
-      { 2, 0, 5, 1, 0, 0 },
-      { 2, 0, 1, 4, 0, 0 },
-      { 3, 0, 0, 4, 0, 0 },
-      { 3, 0, 5, 0, 0, 0 },
-      { 3, 0, 1, 5, 0, 0 },
-      { 3, 0, 4, 1, 0, 0 },
-    };
-
-  // quat indices that make corner cubits bandage the puzzle.
-  private static final int[][] BAD_CORNER_QUATS = new int[][]
-    {
-      { 2, 8,17,23},
-      { 5,11,14,20},
-    };
+  private static final int NUM_STICKERS = 6;
 
   private final int[][] mPermittedAngles;
   private final int[] mCornerQuat;
   private int mPermittedUp, mPermittedDo;
-
-  private static final ObjectSticker[] mStickers;
-
-  static
-    {
-    mStickers = new ObjectSticker[NUM_STICKERS];
-    final float R1 = 0.06f;
-    final float R2 = 0.04f;
-    final float R3 = 0.11f;
-    final float R4 = 0.03f;
-    final float R5 = 0.11f;
-    final float R6 = 0.08f;
-    final float[][] radii  = { {R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3},{R4,R4,R4},{R5,R5,R5,R5},{R6,R6,R6,R6} };
-    final float[] strokes = { 0.05f,0.04f,0.09f,0.05f,0.08f,0.08f };
-
-    for(int s=0; s<NUM_STICKERS; s++)
-      {
-      mStickers[s] = new ObjectSticker(STICKERS[s],null,radii[s],strokes[s]);
-      }
-    }
+  private ObjectSticker[] mStickers;
+  private int[] mQuatNumber;
+  private float[][] mCenters;
+  private int[][] mBadCornerQuats;
+  private int[][] mStickerColor;
+  private int[][] mStickerType;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -171,8 +54,9 @@ class TwistySquare1 extends TwistySquare
     {
     super(size, quat, texture, mesh, effects, moves, ObjectList.SQU1, res, scrWidth);
 
+    if( mBasicAngle==null ) initializeBasicAngle();
     mLastRot = LAST_SL;
-    mPermittedAngles = new int[2][BASIC_ANGLE[0]];
+    mPermittedAngles = new int[2][mBasicAngle[0]];
     mCornerQuat = new int[8];
     }
 
@@ -180,8 +64,9 @@ class TwistySquare1 extends TwistySquare
 
   int[] getSolvedQuats(int cubit, int numLayers)
     {
+    if( mQuats==null ) initializeQuats();
     int status = retCubitSolvedStatus(cubit,numLayers);
-    return status<0 ? null : buildSolvedQuats(MovementSquare.FACE_AXIS[status],QUATS);
+    return status<0 ? null : buildSolvedQuats(MovementSquare.FACE_AXIS[status],mQuats);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -192,6 +77,28 @@ class TwistySquare1 extends TwistySquare
 
     if( variant==0 )
       {
+      double[][] vertices = new double[][]
+        {
+         { -1.5-X, 0.5, 1.5 },
+         {    0.0, 0.5, 1.5 },
+         {    0.0, 0.5,-1.5 },
+         { -1.5+X, 0.5,-1.5 },
+         { -1.5-X,-0.5, 1.5 },
+         {    0.0,-0.5, 1.5 },
+         {    0.0,-0.5,-1.5 },
+         { -1.5+X,-0.5,-1.5 }
+        };
+
+      int[][] vert_indices = new int[][]
+        {
+         {0,1,2,3},
+         {4,5,6,7},
+         {4,5,1,0},
+         {5,6,2,1},
+         {6,7,3,2},
+         {7,4,0,3}
+        };
+
       float[][] bands     = new float[][] { {0.040f,35,0.8f,1.0f,5,2,1}, {0.020f,35,0.8f,1.0f,5,2,1}, {0.001f,35,0.8f,1.0f,5,2,1} };
       int[] bandIndices   = new int[] { 2,2,1,1,0,2 };
       float[][] corners   = new float[][] { {0.03f,0.05f} };
@@ -199,10 +106,29 @@ class TwistySquare1 extends TwistySquare
       float[][] centers   = new float[][] { { -0.75f, 0.0f, 0.0f} };
       int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 };
 
-      return new ObjectShape(VERTICES_MIDDLE,VERT_INDEXES_MIDDLE,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     else if( variant==1 )
       {
+      double[][] vertices = new double[][]
+        {
+         { -X, 0.5, 0.0 },
+         { +X, 0.5, 0.0 },
+         {0.0, 0.5,-1.5 },
+         { -X,-0.5, 0.0 },
+         { +X,-0.5, 0.0 },
+         {0.0,-0.5,-1.5 },
+        };
+
+      int[][] vert_indices = new int[][]
+        {
+         {0,1,2},
+         {3,4,5},
+         {3,4,1,0},
+         {4,5,2,1},
+         {5,3,0,2}
+        };
+
       float[][] bands     = new float[][] { {0.038f,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} };
       int[] bandIndices   = new int[] { 0,1,0,1,1 };
       float[][] corners   = new float[][] { {0.04f,0.15f} };
@@ -210,10 +136,31 @@ class TwistySquare1 extends TwistySquare
       float[][] centers   = new float[][] { { 0.0f, 0.0f,-0.5f} };
       int[] centerIndices = new int[] { 0,0,-1,0,0,-1 };
 
-      return new ObjectShape(VERTICES_EDGE,VERT_INDEXES_EDGE,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     else
       {
+      double[][] vertices = new double[][]
+        {
+         { X-1.5, 0.5,  0.0 },
+         {   0.0, 0.5,  0.0 },
+         {   0.0, 0.5,X-1.5 },
+         {  -1.5, 0.5, -1.5 },
+         { X-1.5,-0.5,  0.0 },
+         {   0.0,-0.5,  0.0 },
+         {   0.0,-0.5,X-1.5 },
+         {  -1.5,-0.5, -1.5 }
+        };
+      int[][] vert_indices = new int[][]
+        {
+         {0,1,2,3},
+         {4,5,6,7},
+         {4,5,1,0},
+         {5,6,2,1},
+         {7,4,0,3},
+         {6,7,3,2}
+        };
+
       float[][] bands     = new float[][] { {0.038f,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} };
       int[] bandIndices   = new int[] { 0,1,0,0,1,1 };
       float[][] corners   = new float[][] { {0.05f,0.13f} };
@@ -221,7 +168,7 @@ class TwistySquare1 extends TwistySquare
       float[][] centers   = new float[][] { { -0.5f, 0.0f,-0.5f} };
       int[] centerIndices = new int[] { -1,0,-1,-1,-1,0,-1,-1 };
 
-      return new ObjectShape(VERTICES_CORNER,VERT_INDEXES_CORNER,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     }
 
@@ -229,7 +176,18 @@ class TwistySquare1 extends TwistySquare
 
   Static4D getQuat(int cubit, int numLayers)
     {
-    return QUATS[QUAT_NUMBER[cubit]];
+    if( mQuats==null ) initializeQuats();
+    if( mQuatNumber ==null )
+      {
+      mQuatNumber = new int[]
+        {
+        0, 6,
+        0, 9, 6, 3, 18, 15, 12, 21,
+        0, 9, 6, 3, 15, 12, 21, 18
+        };
+      }
+
+    return mQuats[mQuatNumber[cubit]];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -250,6 +208,35 @@ class TwistySquare1 extends TwistySquare
 
   ObjectSticker retSticker(int face)
     {
+    if( mStickers==null )
+      {
+      float[][] STICKERS = new float[][]
+        {
+          { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front
+          { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right
+          { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back
+          { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top
+          { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face
+          { -0.2637079f, -0.38185397f, 0.38185397f, -0.38185397f, 0.38185397f, 0.2637079f, -0.5f, 0.5f } // corner top
+        };
+
+      final float R1 = 0.06f;
+      final float R2 = 0.04f;
+      final float R3 = 0.11f;
+      final float R4 = 0.03f;
+      final float R5 = 0.11f;
+      final float R6 = 0.08f;
+      final float[][] radii  = { {R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3},{R4,R4,R4},{R5,R5,R5,R5},{R6,R6,R6,R6} };
+      final float[] strokes = { 0.05f,0.04f,0.09f,0.05f,0.08f,0.08f };
+
+      mStickers = new ObjectSticker[NUM_STICKERS];
+
+      for(int s=0; s<NUM_STICKERS; s++)
+        {
+        mStickers[s] = new ObjectSticker(STICKERS[s],null,radii[s],strokes[s]);
+        }
+      }
+
     return mStickers[face/NUM_FACES];
     }
 
@@ -257,7 +244,33 @@ class TwistySquare1 extends TwistySquare
 
   float[][] getCubitPositions(int numLayers)
     {
-    return CENTERS;
+    if( mCenters==null )
+      {
+      mCenters = new float[][]
+        {
+         { 1.5f, 0.0f, 0.0f },
+         {-1.5f, 0.0f, 0.0f },
+
+         { 0.0f, 1.0f, 1.5f },
+         { 1.5f, 1.0f, 0.0f },
+         { 0.0f, 1.0f,-1.5f },
+         {-1.5f, 1.0f, 0.0f },
+         { 0.0f,-1.0f, 1.5f },
+         { 1.5f,-1.0f, 0.0f },
+         { 0.0f,-1.0f,-1.5f },
+         {-1.5f,-1.0f, 0.0f },
+
+         { 1.0f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f },
+         { 1.0f, 1.0f,-2.0f, 2.0f, 1.0f,-1.0f },
+         {-1.0f, 1.0f,-2.0f,-2.0f, 1.0f,-1.0f },
+         {-1.0f, 1.0f, 2.0f,-2.0f, 1.0f, 1.0f },
+         { 1.0f,-1.0f, 2.0f, 2.0f,-1.0f, 1.0f },
+         { 1.0f,-1.0f,-2.0f, 2.0f,-1.0f,-1.0f },
+         {-1.0f,-1.0f,-2.0f,-2.0f,-1.0f,-1.0f },
+         {-1.0f,-1.0f, 2.0f,-2.0f,-1.0f, 1.0f }
+        };
+      }
+    return mCenters;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -278,6 +291,44 @@ class TwistySquare1 extends TwistySquare
 
   int getFaceColor(int cubit, int cubitface, int numLayers)
     {
+    if( mStickerColor==null )
+      {
+      // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5
+      mStickerColor = new int[][]
+        {
+          { 0, 0, 4, 0, 5, 0 },
+          { 0, 0, 5, 1, 4, 0 },
+
+          { 2, 0, 4, 0, 0, 0 },
+          { 2, 0, 0, 0, 0, 0 },
+          { 2, 0, 5, 0, 0, 0 },
+          { 2, 0, 1, 0, 0, 0 },
+          { 3, 0, 4, 0, 0, 0 },
+          { 3, 0, 0, 0, 0, 0 },
+          { 3, 0, 5, 0, 0, 0 },
+          { 3, 0, 1, 0, 0, 0 },
+
+          { 2, 0, 4, 0, 0, 0 },
+          { 2, 0, 0, 5, 0, 0 },
+          { 2, 0, 5, 1, 0, 0 },
+          { 2, 0, 1, 4, 0, 0 },
+          { 3, 0, 0, 4, 0, 0 },
+          { 3, 0, 5, 0, 0, 0 },
+          { 3, 0, 1, 5, 0, 0 },
+          { 3, 0, 4, 1, 0, 0 },
+        };
+      }
+
+    if( mStickerType==null )
+      {
+      mStickerType = new int[][]
+        {
+          {  NUM_STICKERS,NUM_STICKERS,0,           1,           2,NUM_STICKERS },
+          {             3,NUM_STICKERS,4,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },
+          {             5,NUM_STICKERS,2,           2,NUM_STICKERS,NUM_STICKERS }
+        };
+      }
+
     int variant = getCubitVariant(cubit,numLayers);
     return mStickerType[variant][cubitface]*FACE_COLORS.length + mStickerColor[cubit][cubitface];
     }
@@ -314,24 +365,32 @@ class TwistySquare1 extends TwistySquare
 
   private boolean quatIsBad(int quatIndex, int corner)
     {
+    if( mBadCornerQuats ==null )
+      {
+      // quat indices that make corner cubits bandage the puzzle.
+      mBadCornerQuats = new int[][] { { 2, 8,17,23}, { 5,11,14,20} };
+      }
+
     int index = (corner%2);
 
-    return ( quatIndex==BAD_CORNER_QUATS[index][0] ||
-             quatIndex==BAD_CORNER_QUATS[index][1] ||
-             quatIndex==BAD_CORNER_QUATS[index][2] ||
-             quatIndex==BAD_CORNER_QUATS[index][3]  );
+    return ( quatIndex== mBadCornerQuats[index][0] ||
+             quatIndex== mBadCornerQuats[index][1] ||
+             quatIndex== mBadCornerQuats[index][2] ||
+             quatIndex== mBadCornerQuats[index][3]  );
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
   private boolean isPermittedDo(int angle)
     {
+    if( mQuatMult==null ) initializeQuatMult();
+
     for(int corner=0; corner<8; corner++)
       {
       if( !cornerIsUp(corner) )
         {
         int currQuat = mCornerQuat[corner];
-        int finalQuat= QUAT_MULT[angle][currQuat];
+        int finalQuat= mQuatMult[angle][currQuat];
         if( quatIsBad(finalQuat,corner) ) return false;
         }
       }
@@ -343,12 +402,14 @@ class TwistySquare1 extends TwistySquare
 
   private boolean isPermittedUp(int angle)
     {
+    if( mQuatMult==null ) initializeQuatMult();
+
     for(int corner=0; corner<8; corner++)
       {
       if( cornerIsUp(corner) )
         {
         int currQuat = mCornerQuat[corner];
-        int finalQuat= QUAT_MULT[angle][currQuat];
+        int finalQuat= mQuatMult[angle][currQuat];
         if( quatIsBad(finalQuat,corner) ) return false;
         }
       }
@@ -360,16 +421,18 @@ class TwistySquare1 extends TwistySquare
 
   private void computePermittedAngles()
     {
+    if( mBasicAngle==null ) initializeBasicAngle();
+
     mPermittedDo = 0;
 
-    for(int angle=0; angle<BASIC_ANGLE[0]; angle++)
+    for(int angle=0; angle<mBasicAngle[0]; angle++)
       {
       if( isPermittedDo(angle ) ) mPermittedAngles[0][mPermittedDo++] = angle;
       }
 
     mPermittedUp = 0;
 
-    for(int angle=0; angle<BASIC_ANGLE[0]; angle++)
+    for(int angle=0; angle<mBasicAngle[0]; angle++)
       {
       if( isPermittedUp(angle ) ) mPermittedAngles[1][mPermittedUp++] = angle;
       }
@@ -379,7 +442,8 @@ class TwistySquare1 extends TwistySquare
 
   private int getNextAngle(Random rnd, int layer)
     {
-    int basic = BASIC_ANGLE[0];
+    if( mBasicAngle==null ) initializeBasicAngle();
+    int basic = mBasicAngle[0];
     int num = layer==0 ? mPermittedDo:mPermittedUp;
     int index = rnd.nextInt(num);
     int angle = mPermittedAngles[layer][index];
@@ -390,7 +454,8 @@ class TwistySquare1 extends TwistySquare
 
   private int getNextAngleNotZero(Random rnd, int layer)
     {
-    int basic = BASIC_ANGLE[0];
+    if( mBasicAngle==null ) initializeBasicAngle();
+    int basic = mBasicAngle[0];
     int num = layer==0 ? mPermittedDo:mPermittedUp;
     int index = rnd.nextInt(num-1);
     int angle = mPermittedAngles[layer][index+1];
@@ -426,6 +491,8 @@ class TwistySquare1 extends TwistySquare
 
   private void updateCornerQuats(int[] rotInfo)
     {
+    if( mQuatMult==null ) initializeQuatMult();
+
     int axis = rotInfo[0];
     int layer= rotInfo[1];
     int index=-rotInfo[2];
@@ -437,7 +504,7 @@ class TwistySquare1 extends TwistySquare
       if( cornerBelongs(corner,axis,layer) )
         {
         int curr = mCornerQuat[corner];
-        mCornerQuat[corner] = QUAT_MULT[quat][curr];
+        mCornerQuat[corner] = mQuatMult[quat][curr];
         }
       }
     }
diff --git a/src/main/java/org/distorted/objects/TwistySquare2.java b/src/main/java/org/distorted/objects/TwistySquare2.java
index f13aee89..3a489c32 100644
--- a/src/main/java/org/distorted/objects/TwistySquare2.java
+++ b/src/main/java/org/distorted/objects/TwistySquare2.java
@@ -36,149 +36,18 @@ import java.util.Random;
 
 class TwistySquare2 extends TwistySquare
 {
-  private static final float Y = 0.75f + X/2;
-  private static final float Z = 0.75f - X/2;
-
-  private static final int[] QUAT_NUMBER = new int[]
-    {
-      0, 6,
-      0, 9, 6, 3, 18, 15, 12, 21,
-      0, 9, 6, 3, 0, 9, 6, 3,
-      15, 12, 21, 18, 15, 12, 21, 18
-    };
-
-  // centers of the 2 middles + 8 edges + 8 left corners + 8 right corners
-  private static final float[][] CENTERS = new float[][]
-    {
-      { 1.5f, 0.0f, 0.0f },
-      {-1.5f, 0.0f, 0.0f },
-
-      { 0.0f, 1.0f, 1.5f },
-      { 1.5f, 1.0f, 0.0f },
-      { 0.0f, 1.0f,-1.5f },
-      {-1.5f, 1.0f, 0.0f },
-      { 0.0f,-1.0f, 1.5f },
-      { 1.5f,-1.0f, 0.0f },
-      { 0.0f,-1.0f,-1.5f },
-      {-1.5f,-1.0f, 0.0f },
-
-      {    Y, 1.0f, 1.5f },
-      { 1.5f, 1.0f,   -Y },
-      {   -Y, 1.0f,-1.5f },
-      {-1.5f, 1.0f,    Y },
-      {    Y,-1.0f, 1.5f },
-      { 1.5f,-1.0f,   -Y },
-      {   -Y,-1.0f,-1.5f },
-      {-1.5f,-1.0f,    Y },
-
-      { 1.5f, 1.0f,    Y },
-      {    Y, 1.0f,-1.5f },
-      {-1.5f, 1.0f,   -Y },
-      {   -Y, 1.0f, 1.5f },
-      { 1.5f,-1.0f,    Y },
-      {    Y,-1.0f,-1.5f },
-      {-1.5f,-1.0f,   -Y },
-      {   -Y,-1.0f, 1.5f },
-    };
-
-  private static final double[][] VERTICES_CORNER = new double[][]
-    {
-      { X-1.5+Z, 0.5,  0.0 },
-      {       Z, 0.5,  0.0 },
-      {  -1.5+Z, 0.5, -1.5 },
-      { X-1.5+Z,-0.5,  0.0 },
-      {       Z,-0.5,  0.0 },
-      {  -1.5+Z,-0.5, -1.5 }
-    };
-
-  private static final int[][] VERT_INDEXES_CORNER = new int[][]
-    {
-      {0,1,2},   // counterclockwise!
-      {5,4,3},
-      {3,4,1,0},
-      {4,5,2,1},
-      {5,3,0,2}
-    };
-
-  private static final float[][] STICKERS = new float[][]
-    {
-      { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front
-      { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right
-      { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back
-      { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top
-      { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face
-      { -0.11602539f, -0.25f, 0.4330127f, -0.25f, -0.3169873f, 0.5f }                     // corner top
-    };
-
-  private static final int NUM_STICKERS = STICKERS.length;
-
-  private static final int[][] mStickerType = new int[][]
-    {
-      {  NUM_STICKERS,NUM_STICKERS,0,           1,           2,NUM_STICKERS },
-      {             3,NUM_STICKERS,4,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },
-      {             5,NUM_STICKERS,2,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },
-      {  NUM_STICKERS,           5,2,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS }
-    };
-
-  // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5
-  private static final int[][] mStickerColor = new int[][]
-    {
-      { 0, 0, 4, 0, 5, 0 }, // 0
-      { 0, 0, 5, 1, 4, 0 },
-
-      { 2, 0, 4, 0, 0, 0 }, // 2
-      { 2, 0, 0, 0, 0, 0 },
-      { 2, 0, 5, 0, 0, 0 },
-      { 2, 0, 1, 0, 0, 0 },
-      { 3, 0, 4, 0, 0, 0 },
-      { 3, 0, 0, 0, 0, 0 },
-      { 3, 0, 5, 0, 0, 0 },
-      { 3, 0, 1, 0, 0, 0 },
-
-      { 2, 0, 4, 0, 0, 0 }, // 10
-      { 2, 0, 0, 0, 0, 0 },
-      { 2, 0, 5, 0, 0, 0 },
-      { 2, 0, 1, 0, 0, 0 },
-      { 0, 3, 4, 0, 0, 0 },
-      { 0, 3, 0, 0, 0, 0 },
-      { 0, 3, 5, 0, 0, 0 },
-      { 0, 3, 1, 0, 0, 0 },
-
-      { 0, 2, 0, 0, 0, 0 }, // 18
-      { 0, 2, 5, 0, 0, 0 },
-      { 0, 2, 1, 0, 0, 0 },
-      { 0, 2, 4, 0, 0, 0 },
-      { 3, 0, 0, 0, 0, 0 },
-      { 3, 0, 5, 0, 0, 0 },
-      { 3, 0, 1, 0, 0, 0 },
-      { 3, 0, 4, 0, 0, 0 },
-    };
-
-  private static final ObjectSticker[] mStickers;
-
-  static
-    {
-    mStickers = new ObjectSticker[NUM_STICKERS];
-    final float R1 = 0.06f;
-    final float R2 = 0.04f;
-    final float R3 = 0.11f;
-    final float R4 = 0.03f;
-    final float R5 = 0.11f;
-    final float R6 = 0.025f;
-    final float[][] radii  = { {R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3},{R4,R4,R4},{R5,R5,R5,R5},{R6,R6,R6} };
-    final float[] strokes = { 0.05f,0.04f,0.09f,0.05f,0.08f,0.06f };
-
-    for(int s=0; s<NUM_STICKERS; s++)
-      {
-      mStickers[s] = new ObjectSticker(STICKERS[s],null,radii[s],strokes[s]);
-      }
-    }
+  private static final int NUM_STICKERS = 6;
 
   private int mCurrState;
   private int mIndexExcluded;
   private final ScrambleState[] mStates;
   private int[][] mScrambleTable;
   private int[] mNumOccurences;
+  private int[] mQuatNumber;
+  private float[][] mCenters;
+  private int[][] mStickerColor;
+  private int[][] mStickerType;
+  private ObjectSticker[] mStickers;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -218,33 +87,92 @@ class TwistySquare2 extends TwistySquare
 
     if( variant==0 )
       {
+      double[][] vertices = new double[][]
+        {
+         { -1.5-X, 0.5, 1.5 },
+         {    0.0, 0.5, 1.5 },
+         {    0.0, 0.5,-1.5 },
+         { -1.5+X, 0.5,-1.5 },
+         { -1.5-X,-0.5, 1.5 },
+         {    0.0,-0.5, 1.5 },
+         {    0.0,-0.5,-1.5 },
+         { -1.5+X,-0.5,-1.5 }
+        };
+
+      int[][] vert_indices = new int[][]
+        {
+         {0,1,2,3},
+         {4,5,6,7},
+         {4,5,1,0},
+         {5,6,2,1},
+         {6,7,3,2},
+         {7,4,0,3}
+        };
+
       float[][] bands     = new float[][] { {0.040f,35,0.8f,1.0f,5,2,1}, {0.020f,35,0.8f,1.0f,5,2,1}, {0.001f,35,0.8f,1.0f,5,2,1} };
       int[] bandIndices   = new int[] { 2,2,1,1,0,2 };
       float[][] corners   = new float[][] { {0.03f,0.05f} };
       int[] cornerIndices = new int[] { 0,0,0,0,0,0,0,0 };
       float[][] centers   = new float[][] { { -0.75f, 0.0f, 0.0f} };
       int[] centerIndices = new int[] { 0,0,0,0,0,0,0,0 };
-      return new ObjectShape(VERTICES_MIDDLE,VERT_INDEXES_MIDDLE,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     else if( variant==1 )
       {
+      double[][] vertices = new double[][]
+        {
+         { -X, 0.5, 0.0 },
+         { +X, 0.5, 0.0 },
+         {0.0, 0.5,-1.5 },
+         { -X,-0.5, 0.0 },
+         { +X,-0.5, 0.0 },
+         {0.0,-0.5,-1.5 },
+        };
+
+      int[][] vert_indices = new int[][]
+        {
+         {0,1,2},
+         {3,4,5},
+         {3,4,1,0},
+         {4,5,2,1},
+         {5,3,0,2}
+        };
+
       float[][] bands     = new float[][] { {0.038f,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} };
       int[] bandIndices   = new int[] { 0,1,0,1,1 };
       float[][] corners   = new float[][] { {0.04f,0.15f} };
       int[] cornerIndices = new int[] { 0,0,-1,0,0,-1 };
       float[][] centers   = new float[][] { { 0.0f, 0.0f,-0.5f} };
       int[] centerIndices = new int[] { 0,0,-1,0,0,-1 };
-      return new ObjectShape(VERTICES_EDGE,VERT_INDEXES_EDGE,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     else
       {
+      double[][] vertices = new double[][]
+        {
+         {-0.75f+X/2, 0.5,  0.0 },
+         { 0.75f-X/2, 0.5,  0.0 },
+         {-0.75f-X/2, 0.5, -1.5 },
+         {-0.75f+X/2,-0.5,  0.0 },
+         { 0.75f-X/2,-0.5,  0.0 },
+         {-0.75f-X/2,-0.5, -1.5 }
+        };
+      int[][] vert_indices = new int[][]
+        {
+         {0,1,2},
+         {5,4,3},
+         {3,4,1,0},
+         {4,5,2,1},
+         {5,3,0,2}
+        };
+
       float[][] bands     = new float[][] { {0.030f,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} };
       int[] bandIndices   = new int[] { 0,0,0,1,1 };
       float[][] corners   = new float[][] { {0.05f,0.13f} };
       int[] cornerIndices = new int[] { 0,0,-1,0,0,-1 };
       float[][] centers   = new float[][] { { 0.0f, 0.0f,-0.5f} };
       int[] centerIndices = new int[] { 0,0,-1,0,0,-1 };
-      return new ObjectShape(VERTICES_CORNER,VERT_INDEXES_CORNER,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
+      return new ObjectShape(vertices,vert_indices,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null);
       }
     }
 
@@ -252,7 +180,20 @@ class TwistySquare2 extends TwistySquare
 
   Static4D getQuat(int cubit, int numLayers)
     {
-    return QUATS[QUAT_NUMBER[cubit]];
+    if( mQuats==null ) initializeQuats();
+
+    if( mQuatNumber ==null )
+      {
+      mQuatNumber = new int[]
+        {
+        0, 6,
+        0, 9, 6, 3, 18, 15, 12, 21,
+        0, 9, 6, 3, 0, 9, 6, 3,
+        15, 12, 21, 18, 15, 12, 21, 18
+        };
+      }
+
+    return mQuats[mQuatNumber[cubit]];
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -273,6 +214,35 @@ class TwistySquare2 extends TwistySquare
 
   ObjectSticker retSticker(int face)
     {
+    if( mStickers==null )
+      {
+      float[][] STICKERS = new float[][]
+        {
+          { -0.5f, -0.26289170f, 0.5f, -0.26289170f, 0.5f, 0.26289170f, -0.5f, 0.26289170f }, // middle front
+          { -0.5f, -0.16666667f, 0.5f, -0.16666667f, 0.5f, 0.16666667f, -0.5f, 0.16666667f }, // middle right
+          { -0.5f, -0.45534182f, 0.5f, -0.45534182f, 0.5f, 0.45534182f, -0.5f, 0.45534182f }, // middle back
+          { -0.20096192f, -0.25f, 0.20096192f, -0.25f, 0.0f, 0.5f },                          // edge top
+          { -0.40192384f, -0.5f, 0.40192384f, -0.5f, 0.40192384f, 0.5f, -0.40192384f, 0.5f }, // edge face
+          { -0.11602539f, -0.25f, 0.4330127f, -0.25f, -0.3169873f, 0.5f }                     // corner top
+        };
+
+      final float R1 = 0.06f;
+      final float R2 = 0.04f;
+      final float R3 = 0.11f;
+      final float R4 = 0.03f;
+      final float R5 = 0.11f;
+      final float R6 = 0.025f;
+      final float[][] radii  = { {R1,R1,R1,R1},{R2,R2,R2,R2},{R3,R3,R3,R3},{R4,R4,R4},{R5,R5,R5,R5},{R6,R6,R6} };
+      final float[] strokes = { 0.05f,0.04f,0.09f,0.05f,0.08f,0.06f };
+
+      mStickers = new ObjectSticker[NUM_STICKERS];
+
+      for(int s=0; s<NUM_STICKERS; s++)
+        {
+        mStickers[s] = new ObjectSticker(STICKERS[s],null,radii[s],strokes[s]);
+        }
+      }
+
     return mStickers[face/NUM_FACES];
     }
 
@@ -280,7 +250,45 @@ class TwistySquare2 extends TwistySquare
 
   float[][] getCubitPositions(int numLayers)
     {
-    return CENTERS;
+    if( mCenters ==null )
+      {
+      float Y = 0.75f + X/2;
+
+      mCenters = new float[][]
+        {
+         { 1.5f, 0.0f, 0.0f },
+         {-1.5f, 0.0f, 0.0f },
+
+         { 0.0f, 1.0f, 1.5f },
+         { 1.5f, 1.0f, 0.0f },
+         { 0.0f, 1.0f,-1.5f },
+         {-1.5f, 1.0f, 0.0f },
+         { 0.0f,-1.0f, 1.5f },
+         { 1.5f,-1.0f, 0.0f },
+         { 0.0f,-1.0f,-1.5f },
+         {-1.5f,-1.0f, 0.0f },
+
+         {    Y, 1.0f, 1.5f },
+         { 1.5f, 1.0f,   -Y },
+         {   -Y, 1.0f,-1.5f },
+         {-1.5f, 1.0f,    Y },
+         {    Y,-1.0f, 1.5f },
+         { 1.5f,-1.0f,   -Y },
+         {   -Y,-1.0f,-1.5f },
+         {-1.5f,-1.0f,    Y },
+
+         { 1.5f, 1.0f,    Y },
+         {    Y, 1.0f,-1.5f },
+         {-1.5f, 1.0f,   -Y },
+         {   -Y, 1.0f, 1.5f },
+         { 1.5f,-1.0f,    Y },
+         {    Y,-1.0f,-1.5f },
+         {-1.5f,-1.0f,   -Y },
+         {   -Y,-1.0f, 1.5f },
+        };
+      }
+
+    return mCenters;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -301,6 +309,54 @@ class TwistySquare2 extends TwistySquare
 
   int getFaceColor(int cubit, int cubitface, int numLayers)
     {
+    if( mStickerColor==null )
+      {
+      // YELLOW 0 WHITE 1 BLUE 2 GREEN 3 RED 4 ORANGE 5
+      mStickerColor = new int[][]
+        {
+         { 0, 0, 4, 0, 5, 0 }, // 0
+         { 0, 0, 5, 1, 4, 0 },
+
+         { 2, 0, 4, 0, 0, 0 }, // 2
+         { 2, 0, 0, 0, 0, 0 },
+         { 2, 0, 5, 0, 0, 0 },
+         { 2, 0, 1, 0, 0, 0 },
+         { 3, 0, 4, 0, 0, 0 },
+         { 3, 0, 0, 0, 0, 0 },
+         { 3, 0, 5, 0, 0, 0 },
+         { 3, 0, 1, 0, 0, 0 },
+
+         { 2, 0, 4, 0, 0, 0 }, // 10
+         { 2, 0, 0, 0, 0, 0 },
+         { 2, 0, 5, 0, 0, 0 },
+         { 2, 0, 1, 0, 0, 0 },
+         { 0, 3, 4, 0, 0, 0 },
+         { 0, 3, 0, 0, 0, 0 },
+         { 0, 3, 5, 0, 0, 0 },
+         { 0, 3, 1, 0, 0, 0 },
+
+         { 0, 2, 0, 0, 0, 0 }, // 18
+         { 0, 2, 5, 0, 0, 0 },
+         { 0, 2, 1, 0, 0, 0 },
+         { 0, 2, 4, 0, 0, 0 },
+         { 3, 0, 0, 0, 0, 0 },
+         { 3, 0, 5, 0, 0, 0 },
+         { 3, 0, 1, 0, 0, 0 },
+         { 3, 0, 4, 0, 0, 0 },
+        };
+      }
+
+    if( mStickerType==null )
+      {
+      mStickerType = new int[][]
+        {
+         {  NUM_STICKERS,NUM_STICKERS,0,           1,           2,NUM_STICKERS },
+         {             3,NUM_STICKERS,4,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },
+         {             5,NUM_STICKERS,2,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS },
+         {  NUM_STICKERS,           5,2,NUM_STICKERS,NUM_STICKERS,NUM_STICKERS }
+        };
+      }
+
     int type;
 
          if( cubit< 2             ) type = 0;