#include <bits/stdc++.h>
using namespace std;

int main () {
    const int max_m = 4 * 1000000;
    vector< int > is_prime(max_m + 1, true);
    is_prime[0] = is_prime[1] = false;

    for (int i = 2; i <= max_m; ++i) {
        if (is_prime[i]) {
            for (int d = 2 * i; d < is_prime.size(); d += i) {
                is_prime[d] = false;
            }
        }
    }

    vector< int > corner(max_m + 1, false);
    int d = 1;
    for (int i = 1; i <= max_m;) {
        corner[i] = true;
        if (i + d <= max_m) corner[i + d] = true;
        i += 2 * d;
        d += 1;
    }

    int m, n;

    while (cin >> m >> n, m && n) {
        vector< pair< int, int > > place(m + 1);
        vector< vector< int > > h(2020, vector< int >(2020, 0));

        int x = 1010, y = 1010;
        int dx = 0, dy = 1;
        for (int i = 1; i <= m; ++i) {
            //cerr << x << " " << y << endl;
            h[y][x] = i;
            place[i] = make_pair(y, x);

            if (corner[i]) {
                int ny = dx;
                int nx = -dy;
                dx = nx;
                dy = ny;
            }

            y += dy;
            x += dx;
        }

        const int inf = 1001001001;
        vector< vector< int > > dp(2020, vector<int>(2020, -inf)), pre(2020, vector<int>(2020, -1));
        pair< int, int > s = place[n];
        dp[s.first][s.second] = 0;

//        cerr << s.first << " " << s.second << endl;
//        cerr << h[s.first][s.second] << endl;

        for (int i = 1; i < 2019; ++i) for (int j = 1; j < 2019; ++j) {
        //ragne(i, 1, 2019) range(j, 1, 2019) {
            if (is_prime[h[i][j]]) {
                dp[i][j]++;
                pre[i][j] = h[i][j];
            }

            if (dp[i][j] == -inf) continue;

//            if (dp[i][j] != -inf && h[i][j] != 0) {
//                cerr << i << " " << j << endl;
//                cerr << dp[i][j] << endl;
//            }


            for (int d = -1; d <= 1; ++d) {
                if (dp[i + 1][j + d] < dp[i][j]) {
                    dp[i + 1][j + d] = dp[i][j];
                    pre[i + 1][j + d] = pre[i][j];
                } else if (dp[i + 1][j + d] == dp[i][j]) {
                    pre[i + 1][j + d] = max(pre[i][j], pre[i + 1][j + d]);
                }
            }

            //if (dp[i + 1][j - 1] < dp[i][j]) {
            //    dp[i + 1][j - 1] = dp[i][j];
            //    pre[i + 1][j - 1] = pre[i][j];
            //}

            //if (dp[i + 1][j] < dp[i][j]) {
            //    dp[i + 1][j] = dp[i][j];
            //    pre[i + 1][j] = pre[i][j];
            //}

            //if (dp[i + 1][j + 1] < dp[i][j]) {
            //    dp[i + 1][j + 1] = dp[i][j];
            //    pre[i + 1][j + 1] = pre[i][j];
            //}
        }

        int ansa = -inf, ansb = -1;
        for (int j = 0; j < 2020; ++j) {
            if (ansa < dp.back()[j]) {
                ansa = dp.back()[j];
                ansb = pre.back()[j];
            }
            else if (ansa == dp.back()[j]) {
                ansb = max(ansb, pre.back()[j]);
            }
        }

        if (ansa == 0) {
            cout << 0 << " " << 0 << endl;
        } else {
            cout << ansa << " " << ansb << endl;
        }
    }
}



Measured memory_bytes: 90080