import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Nested Palindromes
 * 
 *  Here are some observations. Because of the no-adjacent-digits constraint, 
 *  no palindrome or sub-palindrome can be of even length. There must always 
 *  be a 'middle' digit. Thus, the only legitimate numbers must be 2^n-1 in length, 
 *  same as the number of moves in a Towers of Hanoi puzzle with n disks. 
 *  In fact, if you letters the digits by first occurrence, you get a string like this: 
 *      abacabadabacaba 
 *  which is the same as the disk moves in ToH. Every digit past 'a' is only adjacent to 'a'.
 *  So, for any digits you don't know, there are 9 possibilities: 
 *      'a' can be anything but 0 (since the number cannot have a leading zero), 
 *      and everything else can be anything but whatever you chose for 'a'. 
 * 
 * @author vanb
 */
public class nested_vanb
{
    public Scanner sc;
    public PrintStream ps;

    // Thinking of this like Towers of Hanoi, 
    // maxlevel is the number of disks
    public int maxlevel = 0;
    
    // The generators are the digits.
    // Think of them like labels on ToH disks.
    public char generators[] = new char[15];
        
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "nested.judge" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "nested.solution" ) );
        
        // These are legitimate lengths.
        // They are powers of 2 minus 1
        int legit[] = new int[20];
        for( int i=0; i<20; i++ )
        {
            legit[i] = (1<<i)-1;
        }
        
        // See which of the ten digits are available for the first place
        boolean avail[] = new boolean[10];

        for(;;)
        {           
            // There are a number of ways we can fail.
            // We'll use this variable to see if any of the happens.
            boolean fail = true;
            
            long n = sc.nextLong();
            if( n==0L ) break;

            char digits[] = sc.next().trim().toCharArray();
            
            // We fail if the digit string isn't of the right length.
            for( int i=0; i<20 && fail; i++ )
            {
                if( digits.length == legit[i] ) fail = false;
            }
                       
            if( !fail )
            {
                // Use dash to indicate that we don't know this digit yet
                Arrays.fill( generators, '-' );
                
                // Determine which ToH Disk is moving.
                // Fun fact: If you count the moves (starting from 1),
                // the disk moving is the position of the lowest 1 bit in the count.
                maxlevel = 0;
                for( int i=0; i<digits.length; i++ )
                {
                    int level = 1;
                    int k = i+1;
                    while( (k&1)==0 )
                    {
                        k >>= 1;
                        level++;
                    }
                    if( level>maxlevel ) maxlevel = level;
                    --level;
                    
                    // Look at the generators. If we don't know it yet, set it.
                    if( generators[level]=='-' || generators[level]=='?' ) generators[level] = digits[i];
                    
                    // If we have a digit mismatch, we fail.
                    if( generators[level]!=digits[i] ) fail = true;
                }
                
                // Can't have '0' as a leading digit.
                if( generators[0]=='0' ) fail = true;
                
                // If we know the first digit, then check all of the others.
                if( Character.isDigit( generators[0] )) for( int i=1; i<maxlevel; i++ )
                {
                    // If it repeats, then we have the same digit next to itself,
                    // and that's a failure.
                    if( generators[i]==generators[0] ) fail = true;
                }
            }
            
            // Convert the number to base 9.
            // After all, there are 9 possibilities for each '?'!
            String base9str = Long.toString( n-1, 9 );
            
            // See how many digits we need
            int need = 0;
            for( int i=0; i<maxlevel; i++ )
            {
                if( generators[i]=='?' ) ++need;
            }
            
            // If we don't need any, and n>1, then we fail
            if( need==0 && n!=1 ) fail=true;
            
            // If the number has more digits than 
            if( need>0 && need<base9str.length() )fail = true;
            String pad = "00000000000000000000" + base9str;
            char base9[] = pad.substring( pad.length()-need, pad.length() ).toCharArray();          
            
            // This is a position in the base 9 number.
            // It tells us the next digit to use.
            int p=0;
            
            // The first digit is special.
            if( digits[0]=='?' )
            {
                // This array will show which digits are available for digit 1
                Arrays.fill( avail, true );
                avail[0] = false;
                
                // If any digit has been used anywhere else in the number,
                // then it's not available for the 1st digit
                for( int i=0; i<maxlevel; i++ )
                {
                    if( generators[i]!='?' ) avail[(int)(generators[i]-'0')] = false;
                }
                
                // Count up to the digit we need, skipping used digits
                int count = (int)(base9[p++]-'0');
                int digit = 1;
                while( digit<10 && !avail[digit] ) ++digit;
                for( int i=0; i<count; i++ )
                {
                    ++digit;
                    while( digit<10 && !avail[digit] ) ++digit;
                }
                
                // If we got a legit digit, store it. Otherwise, fail.
                if( digit<10 ) digits[0] = generators[0] = (char)(digit+'0'); 
                else fail = true;
            }
            
            // Now, fill in the rest.
            if( !fail ) for( int i=1; i<digits.length; i++ ) if( digits[i]=='?' )
            {
                // Use the same bit trick to figure out which generator we need
                int j = i+1;
                int g = 0;
                while( (j&1)==0 )
                {
                    ++g;
                    j>>=1;
                }
                
                // If we don't know this one yet
                if( generators[g]=='?' )
                {
                    // Look at the base 9 number to see what digit to use
                    char ch = base9[p++];
                    
                    // Skip past the digit at position 0
                    if( generators[0]<=ch ) ++ch;
                    generators[g] = digits[i] = ch;
                }
                else
                {
                    // If we know what digit this should be, just record it.
                    digits[i] = generators[g];
                }
            }            
            ps.println( fail ? "-1" : new String( digits ) );
        }
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new nested_vanb().doit();
    }   
}