import java.util.*;
import java.io.*;
import java.math.*;

public class b
{
    public static void main(String Args[]) throws Exception
    {
        
    
        b BB=new b();
    
    }
    
    BigInteger Init;
    BigInteger Final;
    BigInteger Zero;
    
    int MaxBit=0;
    
    
    public b() throws Exception
    {
        int Case=0;

		  Scanner In=new Scanner(System.in);
        Zero=new BigInteger("0"); 
        
        while(true)
        {
            Case++;
            Init=new BigInteger(In.next());
            Final=new BigInteger(In.next());

            if (Init.equals(Zero) && Final.equals(Zero))
            {
                System.exit(0);
            }
            
            
            MaxBit=Init.bitLength();
            if (Final.bitLength()>MaxBit) MaxBit=Final.bitLength();
            
            System.out.print("Case Number " + Case + ": ");
            //System.out.print("" + Init  + "-" + Final);
            
            find();
            System.out.println();
            
            
        
        }
    
    }
    
    
    void find()
    {
        TreeSet<State> Q=new TreeSet<State>();
        Q.add(new State());
        
        while(!Q.isEmpty())
        {
            State S=Q.first();
            Q.remove(S);
            
            if (S.isGoal())
            {
                System.out.print("" + S.Flips);
                return;
            }
            
            S.next(Q);
            //System.out.println(Q.size());
        
        }
        
        System.out.print("impossible");
    
    }
    
    class State implements Comparable
    {
        BigInteger Bulbs;
        BigInteger Flips;
        int FlipCount;
        int NextBit;
        
        State()
        {
            Flips=Zero;
            Bulbs=Init;
            FlipCount=0;
            NextBit=0;
        }
        
        State(State Old, boolean F)
        {
            Bulbs=Old.Bulbs;
            Flips=Old.Flips;
            FlipCount=Old.FlipCount;
            NextBit=Old.NextBit;
            
            if (F)
            {
                FlipCount++;
                
                Flips=Flips.setBit(Old.NextBit);
                if (NextBit-1>=0) Bulbs=Bulbs.flipBit(NextBit-1);
                Bulbs=Bulbs.flipBit(NextBit);
                if (NextBit+1<MaxBit) Bulbs=Bulbs.flipBit(NextBit+1);
                
            }
            
            NextBit++;
            
        }
        
        boolean valid()
        {
            for(int i=NextBit-2; i>=0; i--)
            {
                if(Bulbs.testBit(i)!=Final.testBit(i)) return false;    
            
            }
            return true;
        
        }
        
        boolean isGoal()
        {
            for(int i=0; i<MaxBit; i++)
            {
                if (Final.testBit(i) != Bulbs.testBit(i))
                {
                    return false;
                }
            }
            return true;
        
        }
        
        void next(TreeSet<State> Q)
        {
            if (NextBit+1<MaxBit)
            {
                State nw=new State(this,true);
                if (nw.valid()) Q.add(nw);
                
                nw=new State(this,false);
                if (nw.valid()) Q.add(nw);                
            
            }
        }
        
        public int compareTo(Object O)
        {
            if (O instanceof State)
            {
                State O2=(State)O;
                if (FlipCount < O2.FlipCount) return -1;
                if (FlipCount > O2.FlipCount) return 1;
                if (NextBit > O2.NextBit) return -1;
                if (NextBit < O2.NextBit) return 1;
                
                return (Flips.compareTo(O2.Flips));
                
                
            }
            
            return -1;
        
        }
    
    }



}