Problem: Prime Caves

An international expedition discovered abandoned Buddhist cave temples in a giant cliff standing on the middle of a desert. There were many small caves dug into halfway down the vertical cliff, which were aligned on square grids. The archaeologists in the expedition were excited by Buddha's statues in those caves. More excitingly, there were scrolls of Buddhism sutras (holy books) hidden in some of the caves. Those scrolls, which estimated to be written more than thousand years ago, were of immeasurable value.

The leader of the expedition wanted to collect as many scrolls as possible. However, it was not easy to get into the caves as they were located in the middle of the cliff. The only way to enter a cave was to hang you from a helicopter. Once entered and explored a cave, you can climb down to one of the three caves under your cave; i.e., either the cave directly below your cave, the caves one left or right to the cave directly below your cave. This can be repeated for as many times as you want, and then you can descent down to the ground by using a long rope.

So you can explore several caves in one attempt. But which caves you should visit? By examining the results of the preliminary attempts, a mathematician member of the expedition discovered that (1) the caves can be numbered from the central one, spiraling out as shown in Figure D-1; and (2) only those caves with their cave numbers being prime (let's call such caves prime caves), which are circled in the figure, store scrolls. From the next attempt, you would be able to maximize the number of prime caves to explore.

<image>

Figure D-1: Numbering of the caves and the prime caves


Write a program, given the total number of the caves and the cave visited first, that finds the descending route containing the maximum number of prime caves.

Input

The input consists of multiple datasets. Each dataset has an integer m (1 ≤ m ≤ 106) and an integer n (1 ≤ n ≤ m) in one line, separated by a space. m represents the total number of caves. n represents the cave number of the cave from which you will start your exploration. The last dataset is followed by a line with two zeros.

Output

For each dataset, find the path that starts from the cave n and contains the largest number of prime caves, and output the number of the prime caves on the path and the last prime cave number on the path in one line, separated by a space. The cave n, explored first, is included in the caves on the path. If there is more than one such path, output for the path in which the last of the prime caves explored has the largest number among such paths. When there is no such path that explores prime caves, output "`0 0`" (without quotation marks).

Sample Input


49 22
46 37
42 23
945 561
1081 681
1056 452
1042 862
973 677
1000000 1000000
0 0


Output for the Sample Input


0 0
6 43
1 23
20 829
18 947
10 947
13 947
23 947
534 993541






Example

Input

49 22
46 37
42 23
945 561
1081 681
1056 452
1042 862
973 677
1000000 1000000
0 0


Output

0 0
6 43
1 23
20 829
18 947
10 947
13 947
23 947
534 993541

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>

#define X first
#define Y second
#define MAX 1003
using namespace std;

struct state{
	state():num(0), max(-1), mindex(0){}
	int num;
	int max;
	int mindex;
};

state dp[MAX][MAX];
bool sosuu[1000001];
map<int, pair<int, int> > pos;
int dx[] = {0, -1, 0, 1};
int dy[] = {-1, 0, 1, 0};
int ddx[] = {-1, 0, 1};

//素数判定用
void era(){
	fill(sosuu, sosuu+1000001, true);
	sosuu[0] = false;
	sosuu[1] = false;
	for(int i = 2; i <= 1000000; i++){
		if(sosuu[i]){
			for(int j = 2*i; j <= 1000000; j+=i) sosuu[j] = false;
		}
	}
}

//螺旋状に数字を配置する
void fillNum(){
	int rect = 3, count = 1;
	int x = MAX/2, y = MAX/2;
	pos[count] = pair<int, int>(x, y);
	dp[y][x].num = count++;
	while(count <= MAX*MAX-1){
		pos[count] = pair<int, int>(++x, y);
		dp[y][x].num = count++;
		for(int i = 0; i < 4; i++){
			for(int j = (i==0)?1:0; j < rect-1; j++){
				x += dx[i];
				y += dy[i];
				pos[count] = pair<int, int>(x, y);
				dp[y][x].num = count++;
			}
		}
		rect+=2;
	}
}

//洞穴数は毎回変わるので、入力時にその範囲だけ初期化
void Init(int n){
	for(int i = 0; i < MAX; i++){
		for(int j = 0; j < MAX; j++){
			if(n>=dp[i][j].num){
				dp[i][j].max = -1;
				dp[i][j].mindex = 0;
			}
		}
	}
}
  
//メモ化再帰
//スタートからした三方向に対して再帰回して
//戻ってきたらそこまでの素数洞穴の和を各洞穴に記録していく
int dfs(int x, int y, int n){
	if(dp[y][x].max>=0) return dp[y][x].max;
	int add = 0;
	for(int i = 0; i < 3; i++){
		if(dp[y+1][x+ddx[i]].num>n) continue;//範囲外の洞穴にアクセスしようとしたら止める
		//三方向に対して再帰を行って、もっとも素数洞穴数が多い場所を採用
		//その際、同じ数が複数あった場合はその中で一番大きい素数洞穴を踏んだ経路を採用
		int tmp = dfs(x+ddx[i], y+1, n);
		if(add<tmp){
			add = tmp;
			dp[y][x].mindex = dp[y+1][x+ddx[i]].mindex;
		}
		else if(add == tmp){ 
			dp[y][x].mindex = dp[y][x].mindex<dp[y+1][x+ddx[i]].mindex?dp[y+1][x+ddx[i]].mindex:dp[y][x].mindex;
		}
	}
	//自分が素数だった場合1加算する
	dp[y][x].max = sosuu[dp[y][x].num]?add + 1:add;
	//自分が初めての素数洞穴だった場合
	if(!dp[y][x].mindex&&sosuu[dp[y][x].num]) dp[y][x].mindex = dp[y][x].num;
	return dp[y][x].max;
}

int main(){
	era();
	fillNum();
	int n, m;
	while(cin >> n >> m && (n!=0||m!=0)){
		Init(n);
		int x = pos[m].X, y = pos[m].Y;
		dfs(x, y, n);
		if(dp[y][x].max==0) cout << 0 << " " << 0 << endl;
		else cout << dp[y][x].max << " " << dp[y][x].mindex << endl;
	}
	return 0;
}