// Worm.java

import java.awt.Point;
import java.util.Vector;

class Worm {
   Worm (int x, int y, Wormz w)
   { int nPxl = 40;
      _app = w;
      _lft = 5;  _rit = _app._w+1 - 5;
      _top = 5;  _bot = _app._h+1 - 5;
      _growing = true;  _died = false;  _nextPath = true;  _shinkCorn = false;
      _growPt   = new Point (x, y);
      _shrinkPt = new Point (x, y);
      _tstPt    = new Point (x, y);
      _path = new Vector (10, 2);
      _color = (int)(Math.random () * (double)_app._nPal);
      if (_color >= _app._nPal)  _color = _app._nPal - 1;
      _growDir = (int)(Math.random () * 8D);   if (_growDir > 7) _growDir = 7;
      _path.addElement (new Integer (_growDir));
      _counter = 0;
      _nPxlDraw = 0;   _pxlDraw = new Point [nPxl];
      _nPxlBuff = 0;   _pxlBuff = new Point [nPxl];
      for (int k = 0; k < nPxl; k++) {
         _pxlDraw [k] = new Point (0, 0);
         _pxlBuff [k] = new Point (0, 0);
      }
      _nPxlTest = 5;
      _pxlGotTestPos = new int [_nPxlTest];
      _pxlTest = new Point [_nPxlTest];
      for (int l = 0; l < _nPxlTest; l++)  _pxlTest[l] = new Point (0, 0);
   }

   public void next ()
   {  if (_growing) {
         _tstPt.x = _growPt.x;   _tstPt.y = _growPt.y;
        int i = _growDir;
        Point point = _tstPt;
         point.translate (nextPosCoordXOfs [i], nextPosCoordYOfs [i]);
         _tstPt = point;
         calcTestPos (_growDir);
         if (wInBound ()) {
            if (pxlOff ()) {
               _nPxlDraw = setupPxlDraw (_tstPt, _growDir);
               setPxlGot (true, _pxlDraw, _nPxlDraw);
               _nPxlBuff = setupPxlBuff (_tstPt, _growDir);
               setPxlGot (true, _pxlBuff, _nPxlBuff);
               _growPt.x = _tstPt.x;   _growPt.y = _tstPt.y;   _counter++;
               if (_color < _app._nPal - 1) _color++;   else _color = 0;
            }
            else {
               _growing = false;   _path.addElement (new Integer (_counter));
               _counter = 0;
            }
         }
         else {
            _growing = false;   _path.addElement (new Integer (_counter));
            _counter = 0;
         }
      }
      if (! _growing)
         if (! findNewDirection ()) {
            if (_nextPath && _path.size () > 0) {
               _shrinkDirOld = _shrinkDir;
              Integer integer  = (Integer)_path.elementAt (0);
              Integer integer1 = (Integer)_path.elementAt (1);
               _shrinkDir = integer.intValue ();
               _stepsToGo = integer1.intValue ();
               _nextPath = false;
               _path.removeElementAt (1);
               _path.removeElementAt (0);
            }
            if (_stepsToGo > 0 && !_shinkCorn) {
              int j = _shrinkDir;
              Point point1 = _shrinkPt;
               point1.translate (nextPosCoordXOfs [j], nextPosCoordYOfs [j]);
               _shrinkPt = point1;
               _nPxlDraw = setupPxlDraw (_shrinkPt, _shrinkDir);
               setPxlGot (false, _pxlDraw, _nPxlDraw);
               _nPxlBuff = setupPxlBuff(_shrinkPt, _shrinkDir);
               setPxlGot (false, _pxlBuff, _nPxlBuff);
               _stepsToGo--;
            }
            if (_shinkCorn) {
               _shrinkPt = getCorn(_shrinkPt, _shrinkDirOld, _shrinkDir);
               _nPxlDraw = setupPxlDrawCorn (_shrinkPt,
                                             _shrinkDirOld, _shrinkDir);
               setPxlGot (false, _pxlDraw, _nPxlDraw);
               _nPxlBuff = setupPxlBuffCorn (_shrinkPt,
                                             _shrinkDirOld, _shrinkDir);
               setPxlGot (false, _pxlBuff, _nPxlBuff);
               _stepsToGo--;
               _shinkCorn = false;
            }
            if (_stepsToGo == 0)
               if (_path.size () > 0)
                    {_nextPath = true;   _shinkCorn = true;   return;}
               else {_died = true;  return;}
         }
         else {_growing = true;}
   }

   private boolean findNewDirection ()
   { boolean flag = false;
     int j = 0;
     int k = (int)(Math.random () * 8D);
      while (j < 6 && !flag) {
         while (k == _growDir || k == backtrack [_growDir])
            if (k < 7) k++;  else k = 0;
         _tstPt.x = _growPt.x;   _tstPt.y = _growPt.y;   j++;
         _tstPt = getCorn (_tstPt, _growDir, k);
         calcTestPos (k);
         if (wInBound () && pxlOff ()) {
            _path.addElement (new Integer (k));
            _nPxlDraw = setupPxlDrawCorn(_tstPt, _growDir, k);
            setPxlGot (true, _pxlDraw, _nPxlDraw);
            _nPxlBuff = setupPxlBuffCorn (_tstPt, _growDir, k);
            setPxlGot (true, _pxlBuff, _nPxlBuff);
            _growDir = k;
            _growPt.x = _tstPt.x;   _growPt.y = _tstPt.y;   _counter++;
            flag = true;   _growing = true;   return true;
         }
         if (k < 7) k++;  else k = 0;
      }
      if (!flag) {_growing = false;  return false;}  else {return false;}
   }

   private int setupPxlDrawCorn (Point pt, int dirold, int dirnew)
   { int k = numberCornerDrawPixels [dirold][dirnew];
      for (int l = 0; l < k; l++) {
         _pxlDraw [l].x = pt.x + XOfsCornDraw [dirold][dirnew][l];
         _pxlDraw [l].y = pt.y + YOfsCornDraw [dirold][dirnew][l];
      }
      return k;
   }

   private int setupPxlBuffCorn (Point pt, int dirold, int dirnew)
   { int k = numberCornerBufferPixels [dirold][dirnew];
      for (int l = 0; l < k; l++) {
         _pxlBuff [l].x = pt.x + XOfsCornBuff [dirold][dirnew][l];
         _pxlBuff [l].y = pt.y + YOfsCornBuff [dirold][dirnew][l];
      }
      return k;
   }

   private Point getCorn (Point pt, int dirold, int dirnew)
   {  pt.x += XOfsCorn [dirold][dirnew];
      pt.y += YOfsCorn [dirold][dirnew];
      return pt;
   }

   private void setPxlGot (boolean flag, Point ap [], int np)
   {  for (int k = 0; k < np; k++)
         {_app._pxlGot [ap [k].y * _app._w + ap [k].x] = flag;}
   }

   private int setupPxlBuff (Point pt, int dir)
   { int j = numberBufferPixels [dir];
      for (int k = 0; k < j; k++) {
         _pxlBuff [k].x = pt.x + XOfsPxlBuff [dir][k];
         _pxlBuff [k].y = pt.y + YOfsPxlBuff [dir][k];
      }
      return j;
   }

   private int setupPxlDraw (Point pt, int dir)
   { int j = numberDrawPixels [dir];
      for (int k = 0; k < j; k++) {
         _pxlDraw [k].x = pt.x + XOfsPxlDraw [dir][k];
         _pxlDraw [k].y = pt.y + YOfsPxlDraw [dir][k];
      }
      return j;
   }

   private boolean pxlOff ()
   {  for (int i = 0; i < _nPxlTest; i++)
         if (_app._pxlGot [_pxlGotTestPos [i]])  return false;
      return true;
   }

   private boolean wInBound ()
   {  for (int i = 0; i < _nPxlTest; i++) {
        int x = _pxlTest [i].x;
        int y = _pxlTest [i].y;
         if (x <= _lft || x >= _rit || y <= _top || y >= _bot)  return false;
      }
      return true;
   }

   private void calcTestPos (int i)
   { int j = _app._w;
      for (int k = 0; k < 5; k++) {
        int l  = _tstPt.x + testPosXOfs [i][k];
        int i1 = _tstPt.y + testPosYOfs [i][k];
         _pxlTest [k].x = l;
         _pxlTest [k].y = i1;
         _pxlGotTestPos [k] = i1 * j + l;
      }
   }

   private Point getNextPosCoords (int i, Point point)
   {  point.translate (nextPosCoordXOfs [i], nextPosCoordYOfs [i]);
      return point;
   }

   public boolean canAdd (int x, int y, int d)
   {  _tstPt.x = x;   _tstPt.y = y;   calcTestPos (d);
      return wInBound () && pxlOff ();
   }

   Wormz   _app;
   int     _top, _bot, _lft, _rit;
   Point   _growPt, _shrinkPt, _tstPt;
   int     _color;
   int     _growDir;
   boolean _growing, _died;
   Vector  _path;
   int     _counter;
   int     _shrinkDir;
   int     _shrinkDirOld;
   int     _stepsToGo;
   boolean _nextPath;
   boolean _shinkCorn;
   Point   _pxlDraw [], _pxlBuff [], _pxlTest [];
   int    _nPxlDraw,   _nPxlBuff,   _nPxlTest;
   int     _pxlGotTestPos [];
   static int nextPosCoordXOfs [] = {0, 1, 1, 1, 0, -1, -1, -1};
   static int nextPosCoordYOfs [] = {-1, -1, 0, 1, 1, 1, 0, -1};
   static int testPosXOfs [][] = { {-2, -1, 0, 1, 2},     {-1, 0, 1, 2, 3},
                                   {1, 1, 1, 1, 1},       {3, 2, 1, 0, -1},
                                   {-2, -1, 0, 1, 2},     {-3, -2, -1, 0, 1},
                                   {-1, -1, -1, -1, -1},  {-3, -2, -1, 0, 1} };
   static int testPosYOfs [][] = { {-1, -1, -1, -1, -1},  {-3, -2, -1, 0, 1},
                                   {-2, -1, 0, 1, 2},     {-1, 0, 1, 2, 3},
                                   {1, 1, 1, 1, 1},       {-1, 0, 1, 2, 3},
                                   {-2, -1, 0, 1, 2},     {1, 0, -1, -2, -3} };
   static int numberDrawPixels [] = {3, 5, 3, 5, 3, 5, 3, 5};
   static int XOfsPxlDraw [][] = { {-1, 0, 1},  {-1, -1, 0, 0, 1},
                                   {0, 0, 0},   {1, 0, 0, -1, -1},
                                   {-1, 0, 1},  {-1, 0, 0, 1, 1},
                                   {0, 0, 0},   {1, 1, 0, 0, -1} };
   static int YOfsPxlDraw [][] = { {0, 0, 0},   {-1, 0, 0, 1, 1},
                                   {-1, 0, 1},  {-1, -1, 0, 0, 1},
                                   {0, 0, 0},   {-1, -1, 0, 0, 1},
                                   {-1, 0, 1},  {-1, 0, 0, 1, 1} };
   static int numberBufferPixels [] = {2, 4, 2, 4, 2, 4, 2, 4};
   static int XOfsPxlBuff [][] = { {-2, 2},  {-2, -2, 1, 2},
                                   {0, 0},   {2, 1, -2, -2},
                                   {-2, 2},  {-2, -1, 2, 2},
                                   {0, 0},   {2, 2, -1, -2} };
   static int YOfsPxlBuff [][] = { {0, 0},   {-2, -1, 2, 2},
                                   {-2, 2},  {-2, -2, 1, 2},
                                   {0, 0},   {-2, -2, 1, 2},
                                   {-2, 2},  {-2, -1, 2, 2} };
   static int backtrack [] = {4, 5, 6, 7, 0, 1, 2, 3};
   static int XOfsCorn [][] = {
      {0, 3, 3, 5, 0, -5, -3, -3},   {0, 0, 3, 2, 0, 0, -7, -4},
      {-1, 2, 0, 2, -1, -6, 0, -6},  {0, 2, 3, 0, 0, -4, -7, 0},
      {0, 5, 3, 3, 0, -3, -3, -5},   {0, 0, 7, 4, 0, 0, -3, -2},
      {1, 6, 0, 6, 1, -2, 0, -2},    {0, 4, 7, 0, 0, -2, -3, 0}
   };
   static int YOfsCorn [][] = {
      {0, -2, 1, 6, 0, 6, 1, -2},    {-3, 0, 0, 4, 7, 0, 0, -2},
      {-3, -3, 0, 3, 3, 5, 0, -5},   {-7, -4, 0, 0, 3, 2, 0, 0},
      {0, -6, -1, 2, 0, 2, -1, -6},  {-7, 0, 0, 2, 3, 0, 0, -4},
      {-3, -5, 0, 5, 3, 3, 0, -3},   {-3, -2, 0, 0, 7, 4, 0, 0}
   };
   static int XOfsCornDraw [][][] = {
      { {0},
        {-2, -3, -2, -1, -1, 0, -1, -1, -1, 0, 0, 1},
        {-1, -1, -1, 0, 0, 0},
        {-3, -3, -2, -3, -2, -1, -3, -2, -1, 0,
         -3, -2, -1, -2, -1, -1, 0, 0, 1},
        {0},
        {3, 2, 3, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 2, -1, 0, 0, 1, 1},
        {1, 1, 1, 0, 0, 0},
        {2, 1, 2, 3, 0, 1, 1, -1, 0, 0, 1, 1}
      },
      { {-1, 0, 1, 0, 1, 1, -1, 0, 1},
        {0},
        {-3, -2, -1, -2, -1, -1, 0, 0, 0},
        {-2, -2, -1, -1, 0, -1, -1, 0, 0, 1},
        {1, 0, 1, -1, 0, 1, -1, 0, 1, -1, 0, 1, -1, 0, 1},
        {0},
        {1, 2, 3, 4, 5, 1, 2, 3, 4, 1, 2, 3, 0, 0, 0},
        {2, 1, 2, 0, 1, -1, 0, 0, 1, 1}
      },
      { {-1, 0, 1, -1, 0, 1},
        {-2, -3, -2, -1, -1, 0, -1, -1, -1, 0, 0, 1},
        {0},
        {-1, -1, 0, -3, -2, -1, -2, -1, -1, 0, 0, 1},
        {-1, 0, 1, -1, 0, 1},
        {1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 1, 2, 3, 2, -1, 0, 0, 1, 1},
        {0},
        {2, 1, 2, 3, 0, 1, 2, 3, 4, 1, 2, 3, 4, 5, -1, 0, 0, 1, 1}
      },
      { {-1, 0, 1, -1, 0, 1, -1, 0, 1, 0, 1, 1, -1, 0, 1},
        {-2, -2, -1, -1, 0, -1, -1, 0, 0, 1},
        {-1, -2, -1, -3, -2, -1, 0, 0, 0},
        {0},
        {1, 0, 1, -1, 0, 1, -1, 0, 1},
        {0, 1, 1, 2, 2, -1, 0, 0, 1, 1},
        {1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 0, 0, 0},
        {0}
      },
      { {0},
        {-2, -3, -2, -1, -3, -2, -1, 0, -3, -2,
         -1, -3, -2, -3, -1, -1, 0, 0, 1},
        {-1, -1, -1, 0, 0, 0},
        {-1, -1, 0, -3, -2, -1, -2, -1, -1, 0, 0, 1},
        {0},
        {1, 0, 1, 1, 2, 3, 2, -1, 0, 0, 1, 1},
        {1, 1, 1, 0, 0, 0},
        {2, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 2, 3, 3, -1, 0, 0, 1, 1}
      },
      { {-1, 0, 1, -1, 0, 1, -1, 0, 1, -1, 0, -1, -1, 0, 1},
        {0},
        {-3, -2, -1, -4, -3, -2, -1, -5, -4, -3, -2, -1, 0, 0, 0},
        {-2, -2, -1, -1, 0, -1, -1, 0, 0, 1},
        {-1, -1, 0, -1, 0, 1, -1, 0, 1},
        {0},
        {1, 1, 2, 1, 2, 3, 0, 0, 0},
        {2, 1, 2, 0, 1, -1, 0, 0, 1, 1}
      },
      { {-1, 0, 1, -1, 0, 1},
        {-2, -3, -2, -1, -4, -3, -2, -1, 0, -5,
         -4, -3, -2, -1, -1, -1, 0, 0, 1},
        {0},
        {-5, -4, -3, -2, -1, -4, -3, -2, -1, 0,
         -3, -2, -1, -2, -1, -1, 0, 0, 1},
        {-1, 0, 1, -1, 0, 1},
        {0, 1, 1, 1, 2, 3, 2, -1, 0, 0, 1, 1},
        {0},
        {2, 1, 2, 3, 0, 1, 1, -1, 0, 0, 1, 1}
      },
      { {-1, 0, 1, -1, 0, -1, -1, 0, 1},
        {-2, -2, -1, -1, 0, -1, -1, 0, 0, 1},
        {-5, -4, -3, -2, -1, -4, -3, -2, -1, -3, -2, -1, 0, 0, 0},
        {0},
        {-1, -1, 0, -1, 0, 1, -1, 0, 1, -1, 0, 1, -1, 0, 1},
        {0, 1, 1, 2, 2, -1, 0, 0, 1, 1},
        {1, 2, 3, 1, 2, 1, 0, 0, 0},
        {0}
      }
   };
   static int YOfsCornDraw [][][] = {
      { {0},
        {0, 1, 1, 1, 2, 2, 3, -1, 0, 0, 1, 1},
        {-1, 0, 1, -1, 0, 1},
        {-5, -4, -4, -3, -3, -3, -2, -2, -2, -2,
         -1, -1, -1, 0, 1, 0, 0, -1, -1},
        {0},
        {-5, -4, -4, -3, -3, -3, -2, -2, -2, -2,
         -1, -1, -1, 0, -1, -1, 0, 0, 1},
        {-1, 0, 1, -1, 0, 1},
        {0, 1, 1, 1, 2, 2, 3, 1, 1, 0, 0, -1}
      },
      { {1, 1, 1, 2, 2, 3, 0, 0, 0},
        {0},
        {-1, -1, -1, 0, 0, 1, -1, 0, 1},
        {0, -1, -1, -2, -2, 1, 0, 0, -1, -1},
        {-5, -4, -4, -3, -3, -3, -2, -2, -2, -1, -1, -1, 0, 0, 0},
        {0},
        {-1, -1, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, -1, 0, 1},
        {0, 1, 1, 2, 2, 1, 1, 0, 0, -1}
      },
      { {1, 1, 1, 0, 0, 0},
        {0, 1, 1, 1, 2, 2, 3, -1, 0, 0, 1, 1},
        {0},
        {-3, -2, -2, -1, -1, -1, 0, 1, 0, 0, -1, -1},
        {-1, -1, -1, 0, 0, 0},
        {-3, -3, -3, -3, -3, -2, -2, -2, -2, -2,
         -1, -1, -1, 0, -1, -1, 0, 0, 1},
        {0},
        {0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 1, 1, 0, 0, -1}
      },
      { {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 0, 0, 0},
        {0, 1, 1, 2, 2, -1, 0, 0, 1, 1},
        {-1, 0, 0, 1, 1, 1, -1, 0, 1},
        {0},
        {-3, -2, -2, -1, -1, -1, 0, 0, 0},
        {-2, -2, -1, -1, 0, -1, -1, 0, 0, 1},
        {-1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, -1, 0, 1},
        {0}
      },
      { {0},
        {0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, -1, 0, 0, 1, 1},
        {-1, 0, 1, -1, 0, 1},
        {-3, -2, -2, -1, -1, -1, 0, 1, 0, 0, -1, -1},
        {0},
        {-3, -2, -2, -1, -1, -1, 0, -1, -1, 0, 0, 1},
        {-1, 0, 1, -1, 0, 1},
        {0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 1, 1, 0, 0, -1}
      },
      { {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 0, 0, 0},
        {0},
        {-1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, -1, 0, 1},
        {0, -1, -1, -2, -2, 1, 0, 0, -1, -1},
        {-3, -2, -2, -1, -1, -1, 0, 0, 0},
        {0},
        {-1, 0, 0, 1, 1, 1, -1, 0, 1},
        {0, 1, 1, 2, 2, 1, 1, 0, 0, -1}
      },
      { {1, 1, 1, 0, 0, 0},
        {0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, -1, 0, 0, 1, 1},
        {0},
        {-3, -3, -3, -3, -3, -2, -2, -2, -2, -2,
         -1, -1, -1, 0, 1, 0, 0, -1, -1},
        {-1, -1, -1, 0, 0, 0},
        {-2, -3, -2, -1, -1, -1, 0, -1, -1, 0, 0, 1},
        {0},
        {0, 1, 1, 1, 2, 2, 3, 1, 1, 0, 0, -1}
      },
      { {1, 1, 1, 2, 2, 3, 0, 0, 0},
        {0, 1, 1, 2, 2, -1, 0, 0, 1, 1},
        {-1, -1, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, -1, 0, 1},
        {0},
        {-5, -4, -4, -3, -3, -3, -2, -2, -2, -1, -1, -1, 0, 0, 0},
        {-2, -2, -1, -1, 0, -1, -1, 0, 0, 1},
        {-1, -1, -1, 0, 0, 1, -1, 0, 1},
        {0}
      }
   };
   static int XOfsCornBuff [][][] = {
      { {0},
        {-3, -4, -3, -5, -4, 0, 1, 0, -2, -2, 1, 2},
        {-1, -1, 0, 0, 0, 0},
        {-2, -2, -1, -1, 0, 0, 1, -2, -2, 1, 2},
        {0},
        {2, 1, 2, 0, 1, -1, 0, -2, -1, 2, 2},
        {1, 1, 0, 0},
        {3, 3, 4, 4, 5, -1, 0, 0, -2, -1, 2, 2}
      },
      { {2, 2, 2, 2, -2, 2},
        {0},
        {-4, -3, -2, -1, 0, 0},
        {-2, -2, 1, 2, 0, 1},
        {2, 2, 2, 2, -2, 2},
        {0},
        {1, 2, 3, 4, 0, 0},
        {-2, -1, 2, 2, 3, 3}
      },
      { {-2, 2, -2, 2},
        {-3, -4, -3, 0, 1, -1, 0, -1, -2, -2, 1, 2},
        {0},
        {-1, -1, 0, 0, 1, -4, -3, -3, -2, -2, 1, 2},
        {-2, 2, -2, 2},
        {5, 6, 4, 5, 3, 4, 3, -2, -1, 2, 2},
        {0},
        {3, 3, 4, 4, 5, 5, 6, -2, -1, 2, 2}
      },
      { {2, 2, 2, 2, -2, 2},
        {0, 1, -2, -2, 1, 2},
        {-4, -3, -2, -1, 0, 0},
        {0},
        {2, 2, 2, 2, -2, 2},
        {3, 3, -2, -1, 2, 2},
        {1, 2, 3, 4, 0, 0},
        {0}
      },
      { {0},
        {0, 1, -1, 0, -2, -1, -2, -2, -2, 1, 2},
        {-1, -1, 0, 0},
        {0, 0, 1, -4, -5, -4, -3, -3, -2, -2, 1, 2},
        {0},
        {0, -1, 0, 4, 5, 3, 4, 3, -2, -1, 2, 2},
        {1, 1, 0, 0},
        {-1, 0, 0, 1, 1, 2, 2, -2, -1, 2, 2}
      },
      { {-2, -2, -2, -2, -2, 2},
        {0},
        {-4, -3, -2, -1, 0, 0},
        {-3, -3, -2, -2, 1, 2},
        {-2, -2, -2, -2, -2, 2},
        {0},
        {1, 2, 3, 4, 0, 0},
        {-1, 0, -2, -1, 2, 2}
      },
      { {-2, 2, -2, 2},
        {-3, -4, -3, -5, -4, -6, -5, -2, -2, 1, 2},
        {0},
        {-6, -5, -5, -4, -4, -3, -3, -2, -2, 1, 2},
        {-2, 2, -2, 2},
        {1, 0, 1, 0, -1, 3, 4, 3, -2, -1, 2, 2},
        {0},
        {3, 3, 4, -1, 0, 0, 1, 1, -2, -1, 2, 2}
      },
      { {-2, -2, -2, -2, -2, 2},
        {-3, -3, -2, -2, 1, 2},
        {-4, -3, -2, -1, 0, 0},
        {0},
        {-2, -2, -2, -2, -2, 2},
        {-1, 0, -2, -1, 2, 2},
        {1, 2, 3, 4, 0, 0},
        {0}
      }
   };
   static int YOfsCornBuff [][][] = {
      { {0},
        {-1, 0, 0, 1, 1, 3, 3, 4, -2, 1, 2, 2},
        {-2, 2, -2, 2},
        {-6, -5, -5, -4, -4, -3, -3, 2, 1, -2, -2},
        {0},
        {-6, -5, -5, -4, -4, -3, -3, -2, -2, 1, 2},
        {-2, 2, -2, 2},
        {-1, 0, 0, 1, 1, 3, 3, 4, 2, 2, -1, -2}
      },
      { {1, 2, 3, 4, 0, 0},
        {0},
        {-2, -2, -2, -2, -2, 2},
        {2, 1, -2, -2, -3, -3},
        {-4, -3, -2, -1, 0, 0},
        {0},
        {-2, -2, -2, -2, -2, 2},
        {2, 2, -1, -2, 0, -1}
      },
      { {1, 1, 0, 0},
        {-1, 0, 0, 3, 3, 4, 4, 5, -2, -1, 2, 2},
        {0},
        {-5, -4, -4, -3, -3, 0, 0, 1, 2, 1, -2, -2},
        {-1, -1, 0, 0},
        {-2, -2, -1, -1, 0, 0, 1, -2, -2, 1, 2},
        {0},
        {-1, 0, 0, 1, 1, 2, 2, 2, 2, -1, -2}
      },
      { {1, 2, 3, 4, 0, 0},
        {-3, -3, -2, -1, 2, 2},
        {2, 2, 2, 2, -2, 2},
        {0},
        {-1, -2, -3, -4, 0, 0},
        {0, 1, -2, -2, 1, 2},
        {2, 2, 2, 2, -2, 2},
        {0}
      },
      { {0},
        {3, 3, 4, 4, 5, 5, 6, -2, -1, 2, 2},
        {-2, 2, -2, 2},
        {-4, -3, -3, -1, -1, 0, 0, 1, 2, 1, -2, -2},
        {0},
        {-4, -3, -3, -1, -1, 0, 0, 1, -2, -2, 1, 2},
        {-2, 2, -2, 2},
        {3, 3, 4, 4, 5, 5, 6, 2, 2, -1, -2}
      },
      { {1, 2, 3, 4, 0, 0},
        {0},
        {2, 2, 2, 2, -2, 2},
        {0, 1, 2, 1, -2, -2},
        {-1, -2, -3, -4, 0, 0},
        {0},
        {2, 2, 2, 2, -2, 2},
        {3, 3, 2, 2, -1, -2}
      },
      { {1, 1, 0, 0},
        {-1, 0, 0, 1, 1, 2, 2, -2, -1, 2, 2},
        {0},
        {-2, -2, -1, -1, 0, 0, 1, 2, 1, -2, -2},
        {-1, -1, 0, 0},
        {-5, -4, -4, -3, -3, 0, 0, 1, -2, -2, 1, 2},
        {0},
        {-1, 0, 0, 3, 3, 4, 4, 5, 2, 2, -1, -2}
      },
      { {1, 2, 3, 4, 0, 0},
        {-1, 0, -2, -1, 2, 2},
        {-2, -2, -2, -2, -2, 2},
        {0},
        {-1, -2, -3, -4, 0, 0},
        {-3, -3, -2, -2, 1, 2},
        {-2, -2, -2, -2, -2, 2},
        {0}
      }
   };
   static int numberCornerDrawPixels [][] = {
      {0, 12, 6, 19, 0, 19, 6, 12}, {9, 0, 9, 10, 15, 0, 15, 10},
      {6, 12, 0, 12, 6, 19, 0, 19}, {15, 10, 9, 0, 9, 10, 15, 0},
      {0, 19, 6, 12, 0, 12, 6, 19}, {15, 0, 15, 10, 9, 0, 9, 10},
      {6, 19, 0, 19, 6, 12, 0, 12}, {9, 10, 15, 0, 15, 10, 9, 0}
   };
   static int numberCornerBufferPixels [][] = {
      {0, 12, 4, 11, 0, 11, 4, 12}, {6, 0, 6, 6, 6, 0, 6, 6},
      {4, 12, 0, 12, 4, 11, 0, 11}, {6, 6, 6, 0, 6, 6, 6, 0},
      {0, 11, 4, 12, 0, 12, 4, 11}, {6, 0, 6, 6, 6, 0, 6, 6},
      {4, 11, 0, 11, 4, 12, 0, 12}, {6, 6, 6, 0, 6, 6, 6, 0}
   };
}