private void prioritizeMoves(sizableArray<move> movesToConsider, int depthLeft)
        {
            // Bring any moves which are 'probably good' to the top of our list. Hold an array of bools, and set
            // each one which corresponds to a good move, so that we can avoid moving anything twice.
            bool[] movesReordered = new bool[movesToConsider.Length];
            int[] reorderedMovesToConsider = new int[movesToConsider.Length];
            int reorderedCount = 0;

            int n = 0;
            if (_killerStore != null)
            {
                // If one of these moves caused a cutoff last time, consider that move first.
                foreach (move consideredMove in movesToConsider)
                {
                    if (_killerStore.contains(consideredMove, depthLeft))
                    {
                        movesReordered[n] = true;
                        reorderedMovesToConsider[reorderedCount++] = n;
                    }
                    n++;
                }
            }

            // Consider any capturing or pawn promotions first, too
            n = 0;
            foreach (move thisMove in movesToConsider)
            {
                if (thisMove.isCapture ||      // captures are good.
                    thisMove.isPawnPromotion)  // pawn promotions are good.
                {
                    if (movesReordered[n] == false)
                    {
                        movesReordered[n] = true;
                        reorderedMovesToConsider[reorderedCount++] = n;
                    }
                }
                n++;
            }

            // Swap any good moves such that they are at the top
            int swapCount = 0;
            for (int i = 0; i < reorderedCount; i++)
                movesToConsider.bringToPosition(reorderedMovesToConsider[i], swapCount++);
        }