The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices.  — It is a matter of security to change such things every now and then, to keep the enemy in the dark.  — But look, I have chosen my number 1033 for good reasons. I am the Prime minister, you know!  — I know, so therefore your new number 8179 is also a prime. You will just have to paste four new digits over the four old ones on your office door.  — No, it’s not that simple. Suppose that I change the first digit to an 8, then the number will read 8033 which is not a prime!  — I see, being the prime minister you cannot stand having a non-prime number on your door even for a few seconds.  — Correct! So I must invent a scheme for going from 1033 to 8179 by a path of prime numbers where only one digit is changed from one prime to the next prime.  Now, the minister of finance, who had been eavesdropping, intervened.  — No unnecessary expenditure, please! I happen to know that the price of a digit is one pound.  — Hmm, in that case I need a computer program to minimize the cost. You don't know some very cheap software gurus, do you?  — In fact, I do. You see, there is this programming contest going on... Help the prime minister to find the cheapest prime path between any two given four-digit primes! The first digit must be nonzero, of course. Here is a solution in the case above. 

1033  1733  3733  3739  3779  8779  8179

The cost of this solution is 6 pounds. Note that the digit 1 which got pasted over in step 2 can not be reused in the last step – a new 1 must be purchased.

Input

One line with a positive number: the number of test cases (at most 100). Then for each test case, one line with two numbers separated by a blank. Both numbers are four-digit primes (without leading zeros).

Output

One line for each case, either with a number stating the minimal cost or containing the word Impossible.

Sample Input

3
1033 8179
1373 8017
1033 1033

Sample Output

6
7
0

題目大意：給定兩個四位素數a  b，要求把a變換到b變換的過程要保證  每次變換出來的數都是一個 四位素數，而且當前這步的變換所得的素數

　　　　　與前一步得到的素數  只能有一個位不同，而且每步得到的素數都不能重複。求從a到b最少需要的變換次數。無法變換則輸出Impossible

解題思路：打一個素數表，然後基於每個數的每一位bfs搜尋即可，具體的可見程式碼~~~

程式碼如下

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;
struct node{
    int cur, step;
}now, Next;
int vis[10001], star, finish, prime[10001] = { 0, 0, 1 };
void init(){
    for (int i = 2; i < 10001; i++){
        if (!prime[i]){
            for (int j = 2; i*j < 10001; j++)
                prime[i*j] = 1;
        }
    }
}
int bfs(){
    queue<node> Q;
    vis[star] = 1;
    now.cur = star, now.step = 0;
    Q.push(now);
    while (!Q.empty()){
        int i, j;
        char num[5];
        now = Q.front();
        Q.pop();
        if (now.cur == finish) return now.step;
        for (i = 0; i < 4; i++){
            sprintf(num, "%d", now.cur);
            for (j = 0; j < 10; j++){
                if (j == 0 && i == 0)
                    continue;
                if (i == 0)
                    Next.cur = j * 1000 + (num[1] - '0') * 100 + (num[2] - '0') * 10 + (num[3] - '0');
                else if (i == 1)
                    Next.cur = j * 100 + (num[0] - '0') * 1000 + (num[2] - '0') * 10 + (num[3] - '0');
                else if (i == 2)
                    Next.cur = j * 10 + (num[0] - '0') * 1000 + (num[1] - '0') * 100 + (num[3] - '0');
                else if (i == 3)
                    Next.cur = j + (num[0] - '0') * 1000 + (num[1] - '0') * 100 + (num[2] - '0') * 10;
                if (!prime[Next.cur] && !vis[Next.cur])
                {
                    Next.step = now.step + 1;
                    vis[Next.cur] = 1;
                    Q.push(Next);
                }
            }
        }
    }
    return -1;
}
int main(){
    int t, ans;
    cin >> t;
    init();
    while (t--){
        cin >> star >> finish;
        memset(vis, 0, sizeof(vis));
        ans = bfs();
        if (ans == -1) cout << "Impossible\n";
        else cout << ans << endl;
    }
    return 0;
}