private int find4S_3B_2N1BAt(int row, int col, int playerStone, int exceptDirection)
    {
        int dFond = -1;
        int cd[] = connectedIn8D(playerStone, row, col);
        int ed[] = expandedIn8D(playerStone, row, col);
        for(int d = 0; d < 4; d++)
        {
            if(d == exceptDirection)
                continue;
            if(stones[row][col] == playerStone)
            {
                int nConnect = cd[d] + cd[d + 4] + 1;
                int nFree1 = ed[d] - cd[d];
                int nFree2 = ed[d + 4] - cd[d + 4];
                boolean b4S = nConnect >= 4 && (nFree1 >= 1 || nFree2 >= 1);
                boolean b3B = nConnect >= 3 && nFree1 >= 1 && nFree2 >= 1;
                if(b4S || b3B)
                {
                    dFond = d;
                    break;
                }
            }
            if(stones[row][col] != 0)
                continue;
            int nFree1 = ed[d] - cd[d];
            int nFree2 = ed[d + 4] - cd[d + 4];
            boolean b2N1 = cd[d] >= 2 && cd[d + 4] >= 1 || cd[d] >= 1 && cd[d + 4] >= 2;
            boolean bSFree = nFree1 >= 1 && nFree2 >= 1;
            if(!b2N1 || !bSFree)
                continue;
            dFond = d;
            break;
        }

        return dFond;
    }

    private int find4S_3B_2N1B(int playerStone, int exceptDirection, int rTest, int cTest, boolean only4S)
    {
        int dFond = -1;
        int rMin = rTest - 3;
        if(rMin < 0)
            rMin = 0;
        int rMax = rTest + 3;
        if(rMax > borderSize)
            rMax = borderSize;
        int cMin = cTest - 3;
        if(cMin < 0)
            cMin = 0;
        int cMax = cTest + 3;
        if(cMax > borderSize)
            cMax = borderSize;
        for(int r = rMin; r < rMax; r++)
        {
            for(int c = cMin; c < cMax; c++)
            {
                if(stones[r][c] != playerStone && stones[r][c] != 0)
                    continue;
                if(only4S)
                    dFond = find4SAt(r, c, playerStone, exceptDirection);
                else
                    dFond = find4S_3B_2N1BAt(r, c, playerStone, exceptDirection);
                if(dFond != -1)
                    break;
            }

            if(dFond != -1)
                break;
        }

        return dFond;
    }

    private Dot thinkInNumber(int stonePlayer, int nl)
    {
        if(stoneCounter[stonePlayer] < nl - 1)
            return null;
        int maxGain = 0;
        Dot dot = null;
        for(int r = 0; r < borderSize; r++)
        {
            for(int c = 0; c < borderSize; c++)
            {
                int gain = thinkInNumberAt(stonePlayer, r, c, nl);
                if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
                {
                    maxGain = gain;
                    dot = new Dot(r, c);
                }
            }

        }

        return dot;
    }

    private int thinkInNumberAt(int lineStone, int row, int col, int nl)
    {
        int lines = 0;
        int otherGain = 0;
        if(stones[row][col] == 0)
        {
            int cd[] = connectedIn8D(lineStone, row, col);
            int ed[] = expandedIn8D(lineStone, row, col);
            for(int i = 0; i < 4; i++)
                if(ed[i] + ed[i + 4] + 1 >= 5)
                {
                    int l = cd[i] + cd[i + 4] + 1;
                    if(l >= nl)
                        lines++;
                    else
                        otherGain += 2 ^ l;
                }

        }
        return lines > 0 ? lines * 32 + otherGain : 0;
    }

    private int[] expandedIn8D(int stone, int row, int col)
    {
        int ed[] = new int[8];
        for(int d = 0; d < 8; d++)
            ed[d] = expandedIn1D(stone, row, col, d);

        return ed;
    }

    private int expandedIn1D(int stone, int row, int col, int direction)
    {
        int n = 0;
        int cn = 0;
        Dot d = new Dot(row, col);
        while(cn < 4) 
        {
            d.copyFrom(forwardOneStep(d, direction));
            if(!d.inBorder(borderSize))
                break;
            int st = stones[d.row][d.col];
            if(st == 0)
                cn++;
            if(st != stone && st != 0)
                break;
            n++;
        }
        return n;
    }

    private Dot maxGainedDot()
    {
        Dot dotWithMaxGain = null;
        int maxGain = 0;
        for(int r = 0; r < borderSize; r++)
        {
            for(int c = 0; c < borderSize; c++)
            {
                int gain = gainAt(r, c);
                if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
                {
                    maxGain = gain;
                    dotWithMaxGain = new Dot(r, c);
                }
            }

        }

        return dotWithMaxGain;
    }

    private int gainAt(int row, int col)
    {
        if(stones[row][col] == 0)
        {
            int gain = 0;
            for(int d = 0; d < 8; d++)
            {
                int gd = gainAtDirection(row, col, d);
                if(gd == 0)
                    gain >>= 2;
                else
                    gain += gd;
            }

            if(gain < 1)
                gain = 1;
            return gain;
        } else
        {
            return 0;
        }
    }

    private int gainAtDirection(int row, int col, int direction)
    {
        int gain = 0;
        Dot d = new Dot(row, col);
        int step = 0;
        do
        {
            d.copyFrom(forwardOneStep(d, direction));
            step++;
            if(!d.inBorder(borderSize))
                break;
            int stone = stones[d.row][d.col];
            if(stone == 2)
                break;
            int gainByStone = stone == 1 ? 5 : 1;
            gain += gainByStep(step) * gainByStone;
        } while(true);
        return gain;
    }

    private int gainByStep(int step)
    {
        int gain = (borderSize - step) / 2;
        if(gain < 1)
            gain = 1;
        return gain;
    }

    private int exist2N1(int row, int col, int playerStone, int exceptDirection)
    {
        int cd[] = connectedIn8D(playerStone, row, col);
        int ed[] = expandedIn8D(playerStone, row, col);
        int existDirection = -1;
        for(int i = 0; i < 4; i++)
        {
            if(i == exceptDirection || (cd[i] < 2 || cd[i + 4] < 1) && (cd[i] < 1 || cd[i + 4] < 2) || (ed[i] - cd[i]) + (ed[i + 4] - cd[i + 4]) <= 0)
                continue;
            existDirection = i;
            break;
        }

        return existDirection;
    }

    private int existNLineWithMinFree(int row, int col, int n, int minFree, int exceptDirection)
    {
        int stone = stones[row][col];
        int cd[] = connectedIn8D(stone, row, col);
        int ed[] = expandedIn8D(stone, row, col);
        int existDirection = -1;
        for(int i = 0; i < 4; i++)
        {
            if(i == exceptDirection || cd[i] + cd[i + 4] + 1 < n || (ed[i] - cd[i]) + (ed[i + 4] - cd[i + 4]) < minFree)
                continue;
            existDirection = i;
            break;
        }

        return existDirection;
    }

    private int[] connectedIn8D(int stone, int row, int col)
    {
        int cd[] = new int[8];
        for(int d = 0; d < 8; d++)
            cd[d] = connectedIn1D(stone, row, col, d);

        return cd;
    }

    private int connectedIn1D(int stone, int row, int col, int direction)
    {
        int n = 0;
        Dot d = new Dot(row, col);
        do
        {
            d.copyFrom(forwardOneStep(d, direction));
            if(d.inBorder(borderSize) && stones[d.row][d.col] == stone)
                n++;
            else
                return n;
        } while(true);
    }

    private Dot forwardOneStep(Dot d, int direction)
    {
        int r = d.row;
        int c = d.col;
        switch(direction)
        {
        case 0: // '\0'
            c++;
            break;

        case 1: // '\001'
            r--;
            c++;
            break;

        case 2: // '\002'
            r--;
            break;

        case 3: // '\003'
            r--;
            c--;
            break;

        case 4: // '\004'
            c--;
            break;

        case 5: // '\005'
            r++;
            c--;
            break;

        case 6: // '\006'
            r++;
            break;

        case 7: // '\007'
            r++;
            c++;
            break;
        }
        return new Dot(r, c);
    }

    private boolean randomTrue()
    {
        return rnd.nextInt() % 2 == 0;
    }


}