TwistyPuzzleLib

  static final int[] SUPPORTED = {4,8,12,16,20,24};

  private static final int HEADER_SIZE = 6;

    mData[3] = (byte)(mNumBuckets>>>16);

    mData[4] = (byte)(mNumBuckets>>> 8);

    mData[5] = (byte)(mNumBuckets&0xff);

      case 12: ret = (bits%8)!=0 ? (((mData[bytes]&0xf)<<8) + (mData[bytes+1]&0xff)) : (((mData[bytes]&0xff)<<4) + ((mData[bytes+1]>>>4)&0xf));

               break;

      case 16: ret = ((mData[bytes]&0xff)<<8) + (mData[bytes+1]&0xff);

               break;

      case 20: if( (bits%8) !=0 ) ret = (((mData[bytes]&0x0f)<<16) + ((mData[bytes+1]&0xff)<<8) + ( mData[bytes+2]     &0xff));

               else               ret = (((mData[bytes]&0xff)<<12) + ((mData[bytes+1]&0xff)<<4) + ((mData[bytes+2]>>>4)&0x0f));

      case 24: ret = ((mData[bytes]&0xff)<<16) + ((mData[bytes+1]&0xff)<<8) + (mData[bytes+2]&0xff);

                 mData[bytes+1]= (byte)((byte)(value<<4) + (mData[bytes+1]&0xf));

               break;

      case 20: if( (bits%8) !=0 )

                 {

                 mData[bytes]  = (byte)((mData[bytes]&(~0xf)) + (value>>>16));

                 mData[bytes+1]= (byte)(value>>>8);

                 mData[bytes+2]= (byte)(value&(0xff));

                 }

               else

                 {

                 mData[bytes]  = (byte)(value>>>12);

                 mData[bytes+1]= (byte)(value>>>4);

                 mData[bytes+2]= (byte)((byte)(value<<4) + (mData[bytes+2]&0xf));

                 }

               break;

      case 24: mData[bytes]   = (byte)(value>>>16);

               mData[bytes+1] = (byte)(value>>>8);

               mData[bytes+2] = (byte)(value&(0xff));

               break;

// only numBits = 4,8,12,16,20,24 actually supported

    for(int i=0; i<SUPPORTED.length; i++)

      int approx = computeApproximateSize( tableSize, size, SUPPORTED[i]);

      android.util.Log.e("D", "trying numBits: "+SUPPORTED[i]+" approx size: "+approx);

    construct(table,level,SUPPORTED[chosen]);

    mNumBuckets  =((((int)mData[3])&0xff)<<16) + ((((int)mData[4])&0xff)<<8) + ((int)mData[5])&0xff;

      for( int supp : PruningTable.SUPPORTED )

        {

        PruningTable table = new PruningTable(mTablebase, level, supp);

        int size = mTablebase.getSize();

        StringBuilder sb = new StringBuilder();

        int num = 0;

        for(int i=0; i<size; i++)

          if (table.belongs(i))

            {

            if ((num % 10) == 0) sb.append("\n");

            num++;

            sb.append(i);

            sb.append(' ');

            }

        android.util.Log.e("D", "numbers: " + sb);

        }

public class TablebasesCube2 extends TablebasesPruning

    super(res, new int[] {R.raw.cube_2_pruning5}, new int[] {R.raw.cube_2_pruning11} );

  int[] getMidPruningLevels()

    return new int[] {4,5};

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  int[] getHighPruningLevels()

    {

    return null;//new int[] {11};

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  int getGodsNumber()

    {

    return 11;

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.objectlib.tablebases;

import android.content.res.Resources;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

///////////////////////////////////////////////////////////////////////////////////////////////////

public abstract class TablebasesPruning extends TablebasesAbstract

{

  private boolean mInitialized;

  private PruningTable[] mHighTables;

  private PruningTable[] mMidTables;

  private int mGodsNumber, mLowestHigh, mHighestMid, mLowestMid;

///////////////////////////////////////////////////////////////////////////////////////////////////

  abstract int[] getMidPruningLevels();

  abstract int[] getHighPruningLevels();

  abstract int getGodsNumber();

///////////////////////////////////////////////////////////////////////////////////////////////////

  private PruningTable createPruningTable(Resources res, int id)

    {

    InputStream stream = res.openRawResource(id);

    ByteArrayOutputStream buffer = new ByteArrayOutputStream();

    int nRead;

    byte[] tmp = new byte[16384];

    try

      {

      while ((nRead = stream.read(tmp, 0, tmp.length)) != -1)

        {

        buffer.write(tmp, 0, nRead);

        }

      stream.close();

      byte[] data = buffer.toByteArray();

      buffer.close();

      return new PruningTable(data);

      }

    catch(IOException ex)

      {

      mInitialized = false;

      return null;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public TablebasesPruning()

    {

    super();

    mGodsNumber = getGodsNumber();

    mInitialized = false;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public TablebasesPruning(Resources res, int[] midIDs, int[] highIDs)

    {

    super();

    int mid = midIDs !=null ? midIDs.length  : 0;

    int high= highIDs!=null ? highIDs.length : 0;

    mMidTables = mid >0 ? new PruningTable[mid] : null;

    mHighTables= high>0 ? new PruningTable[high]: null;

    mGodsNumber = getGodsNumber();

    mInitialized = true;

    for(int i=0; i<mid ; i++) mMidTables[i] = createPruningTable(res,midIDs[i] );

    for(int i=0; i<high; i++) mHighTables[i]= createPruningTable(res,highIDs[i]);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public byte[][] getPacked()

    {

    if( !mInitialized )

      {

      int[] midLevels = getMidPruningLevels();

      int numMidLevels= midLevels!=null ? midLevels.length : 0;

      int[] highLevels = getHighPruningLevels();

      int numHighLevels= highLevels!=null ? highLevels.length : 0;

      int maxLevel = 0;

      if( highLevels!=null )

        {

        for( int l : highLevels )

          if( l>maxLevel ) maxLevel = l;

        }

      else

        {

        if( midLevels!=null )

          for( int l : midLevels )

            if( l>maxLevel ) maxLevel = l;

        }

      createTablebase(maxLevel);

      mMidTables = numMidLevels >0 ? new PruningTable[numMidLevels ] : null;

      mHighTables= numHighLevels>0 ? new PruningTable[numHighLevels] : null;

      for(int i=0; i<numMidLevels; i++)

        mMidTables[i] = new PruningTable(mTablebase,midLevels[i]);

      for(int i=0; i<numHighLevels; i++)

        mHighTables[i] = new PruningTable(mTablebase,highLevels[i]);

      mInitialized = true;

      }

    int midNum  = mMidTables !=null ? mMidTables.length  : 0;

    int highNum = mHighTables!=null ? mHighTables.length : 0;

    byte[][] data = new byte[midNum+highNum][];

    for(int i=0; i<midNum ; i++) data[i       ] = mMidTables[i].getPacked();

    for(int i=0; i<highNum; i++) data[i+midNum] = mHighTables[i].getPacked();

    return data;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int[][] solution(int index, int[] extra)

    {

    return null;

    }

}