#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

//#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
//#endif

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#include <array>
//#include <atomic>
#include <chrono>
//#include <condition_variable>
#include <forward_list>
//#include <future>
#include <initializer_list>
//#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <system_error>
//#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>

using namespace std;


int main ()
{
	int M , N;
	int ii[1000];
	for( size_t i = 0; i < 1000; i++ )
	{
		ii[i] = i*i;
	}

	int dx[] = { 1 , 0 , -1 , 0 };
	int dy[] = { 0 , -1 , 0 , 1 };
	vector<vector<int>>data ( 1e3 + 5 , vector<int> ( 1e3 + 5 , INT_MAX ) );
	{
		int nowx = ( 1e3 / 2 + 1 ) , nowy = ( 1e3 / 2 ) + 1;
		int nowz = 3;
		for( size_t i = 1; i < 1e6 + 10; i++ )
		{
			if( data[nowx + dx[( nowz + 1 ) % 4]][nowy + dy[( nowz + 1 ) % 4]] == INT_MAX )
			{
				nowz = ( nowz + 1 ) % 4;
			}
			data[nowx + dx[nowz]][nowy + dy[nowz]] = i;

			nowx = nowx + dx[nowz];
			nowy = nowy + dy[nowz];
		}
	}
	bool pri[(int) ( 1e6 + 3 )];
	pri[0] = 1;
	pri[1] = 1;
	for( size_t i = 2; i < 1e6 + 3; i++ )
	{
		if( pri[i] == 0 )
		{
			for( size_t j = 2; j*i < 1e6 + 3; j++ )
			{
				pri[i*j] = 1;
			}
		}
	}
	while( cin >> M >> N , M || N )
	{
		pair<int , int>S;
		int ans1 = 0 , ans2 = 0;
		//vector<vector<int>>data2 ( 1e3 + 5 , vector<int> ( 1e3 + 5 , 0 ) );
		map < int , map < int , int >>data2;
		for( size_t i = 0; i < 1e3 + 5; i++ )
		{
			for( size_t j = 0; j < 1e3 + 5; j++ )
			{
				if( data[i][j] == N )
				{
					S.first = i;
					S.second = j;
					break;
				}
			}
			if( S.first )
			{
				break;
			}
		}
		queue<pair<int , int>>que;
		que.push ( S );
		if( !pri[data[S.first][S.second]] )
		{
			ans1 = data[S.first][S.second];
			ans2 = 1;
			data2[S.first][S.second] = 1;
		}
		while( que.size () )
		{
			pair<int , int>now = que.front (); que.pop ();
			int nowx = now.first;
			int nowy = now.second;
			//cout << data[nowx][nowy] << endl;
			for( int i = 1; i >= -1; i-- )
			{
				if( !( nowx + 1 < 1e3 + 5 && nowy + i < 1e3 + 5 && nowy + i >= 0 ) )continue;
				if( data[nowx][nowy] != 2 && nowx + 1 + nowy + i % 2 == 0 )continue;
				if( data[nowx + 1][nowy + i] <= M )
				{
					if( !data2[nowx + 1][nowy + i] )que.push ( pair<int , int> ( nowx + 1 , nowy + i ) );
					if( !pri[data[nowx + 1][nowy + i]] )
					{
						if( data2[nowx + 1][nowy + i] < data2[nowx][nowy] + 1 )
						{
							data2[nowx + 1][nowy + i] = data2[nowx][nowy] + 1;
							if( ans2 <= data2[nowx + 1][nowy + i] )
							{
								if( ans2 == data2[nowx + 1][nowy + i] )
								{
									ans1 = max ( data[nowx + 1][nowy + i] , ans1 );
								} else
								{
									ans1 = data[nowx + 1][nowy + i];
								}
								ans2 = data2[nowx + 1][nowy + i];
							}
						}
					} else
					{
						if( data2[nowx + 1][nowy + i] < data2[nowx][nowy] )
						{
							data2[nowx + 1][nowy + i] = data2[nowx][nowy];
						}
					}

				}
			}
		}
		cout << ans2 << " " << ans1 << endl;
	}
}

Measured memory_bytes: 34528