const int dir[][] = {{-, }, {, }, {, }, {, -}};

 int vis[maxn], d[maxn];

 bool is_ok(int x, int y)///坐标是否合格，按照题意来进行

 {

     if(x< || y<||x>n||y>n)

         return false;

     return true;

 }

 int dfs(Node st,Node ed)///起点终点

 {

     queue<Node> q;

     q.push(st);///压进起点

     memset(vis,,sisteof(vis));

     memset(d,,sizeof(d));

     int ss = a[st.x][st.y];

     d[ss] = ;

     int edd = a[ed.x][ed.y];

     while(!q.empty())

     {

         Node c = q.front(),v;

         q.pop();

         int stt = a[c.x][c.y];

         if(stt == edd)///先判断是否到达终点

             return d[stt];

         repu(i,,)

         {

             v.x = c.x + dir[i][];

             v.y = c.y + dir[i][];

             if(is_ok(v.x,v.y))///坐标是否合格

             {

                 int sd = a[v.x][v.y];

                 if(!vis[sd])///符合所有条件后

                 {

                     q.push(v);///压进

                     vis[sd] = ;///V过

                     d[sd] = d[stt] + ;///步数为之前的+1

                 }

             }

             else

                 continue;

         }

     }

     return -;

 }

 #include <iostream>

 #include <cstdio>

 #include <cmath>

 #include <cstring>

 #include <cstdlib>

 #include <string>

 #include <vector>

 #include <algorithm>

 #include<queue>

 #include <set>

 #define repu(i,a,b) for(int i=a;i<b;i++)

 using namespace std;

 #define N 1000010

 #define ll long long

 #define _cle(m, a) memset(m, a, sizeof(m))

 const int maxn = ;

 const int mn = ;

 int tot;

 int a[][];

 struct Node

 {

     int x, y;

 } nodes[maxn];

 void init()

 {

     memset(a, , sizeof(a));

     a[mn][mn] = ;

     tot = ;

     nodes[].x = mn;

     nodes[].y = mn;

     int cur = ;

     int i = mn, j = mn+;

     while(tot <= maxn)

     {

         int t;

         t = ;

         i++;

         while(t < cur*)

         {

             a[--i][j] = ++tot;

             nodes[tot].x = i;

             nodes[tot].y = j;

             t++;

         }

         t = ;

         while(t < cur*)

         {

             a[i][--j] = ++tot;

             nodes[tot].x = i;

             nodes[tot].y = j;

             t++;

         }

         t = ;

         while(t < cur*)

         {

             a[++i][j] = ++tot;

             nodes[tot].x = i;

             nodes[tot].y = j;

             t++;

         }

         t = ;

         while(t < cur*)

         {

             a[i][++j] = ++tot;

             nodes[tot].x = i;

             nodes[tot].y = j;

             t++;

         }

         ++j;

         cur++;

     }

 }

 int prime[maxn];

 void is_prime()

 {

     memset(prime, , sizeof(prime));

     int m = sqrt(maxn+0.5);

     prime[] = prime[] = ;

     for(int i = ; i <= m; i++)

     {

         if(!prime[i])

         {

             for(int j = i*i; j <= maxn; j+=i)

             {

                 prime[j] = ;

             }

         }

     }

 }

 const int dir[][] = {{-, }, {, }, {, }, {, -}};

 int vis[maxn], d[maxn];

 bool is_ok(int x, int y)

 {

     return x>= && y >=;

 }

 int bfs(Node z,Node b)

 {

     queue<Node> q;

     q.push(z);

     memset(vis,,sizeof(vis));

     memset(d,,sizeof(d));

     int ss = a[z.x][z.y];

     d[ss] = ;

     int ed = a[b.x][b.y];

     while(!q.empty())

     {

         Node c = q.front(),v;

         q.pop();

         int st = a[c.x][c.y];

         if(st == ed)

             return d[st];

         repu(i,,)

         {

             v.x = c.x + dir[i][];

             v.y = c.y + dir[i][];

             if(is_ok(v.x,v.y))

             {

                 int sd = a[v.x][v.y];

                 if(!vis[sd]&&prime[sd])

                 {

                     q.push(v);

                     vis[sd] = ;

                     d[sd] = d[st] + ;

                 }

             }

             else

                 continue;

         }

     }

     return -;

 }

 int main()

 {

     init();

     is_prime();

     int x, y, kase = ;

     while(~scanf("%d%d", &x, &y))

     {

         if(!prime[x] || !prime[y])

         {

             printf("Case %d: impossible\n", ++kase);

             continue;

         }

         int ans = bfs(nodes[x], nodes[y]);

         if(ans == -) printf("Case %d: impossible\n", ++kase);

         else printf("Case %d: %d\n", ++kase, ans);

     }

     return ;

 }