import java.io.PrintStream;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.Scanner;

/**
 * Solution to Recovery
 * 
 * @author vanb
 */
public class recovery_vanb
{
    private static Scanner sc;
    private static PrintStream ps;
        
    /**
     * Do it!
     */
    private void doit()
    {  
        // Read in the parity strings
        char rows[] = sc.next().toCharArray();
        char cols[] = sc.next().toCharArray();
        int n = rows.length;
        int m = cols.length;
        
        // Start with a matrix of all 1s.
        // Change 1s to 0s as necessary.
        char matrix[][] = new char[n][m];
        for( int i=0; i<n; i++ ) Arrays.fill( matrix[i], '1' );
        
        // This is the parity of every row & column of a matrix of all 1s
        char rowparity = (m%2==0) ? '0' : '1';
        char colparity = (n%2==0) ? '0' : '1';
        
        // See which rows are OK, which are not.
        // Count the number of rows that have the wrong parity.
        boolean rowok[] = new boolean[n];
        int rowcount = 0;
        for( int i=0; i<n; i++ )
        {
            rowok[i] = (rows[i]==rowparity);   
            if( !rowok[i] ) ++rowcount;
        }
        
        // Now, do the same for columns.
        boolean colok[] = new boolean[m];
        int colcount = 0;
        for( int j=0; j<m; j++ )
        {
            colok[j] = (cols[j]==colparity); 
            if( !colok[j] ) ++colcount;
        }
                      
        // If the difference between rowcount and colcount is odd,
        // then we can't find a solution.
        boolean solved = false;
        if( rowcount%2 == colcount%2 )
        {
            // If it's even, then we can.
            solved = true;
            
            if( rowcount>colcount )
            {
                // More rows out of sync than cols?
                // Fix the difference in the first column.
                for( int i=0, c=rowcount-colcount; i<n && c>0; i++ ) if( !rowok[i] )
                {
                    matrix[i][0] = '0';
                    rowok[i] = true;
                    --c;
                }
            }
            else
            {
                // More cols out of sync than rows?
                // Fix the difference in the first row.
                for( int j=0, c=colcount-rowcount; j<m && c>0; j++ ) if( !colok[j] )
                {
                    matrix[0][j] = '0';
                    colok[j] = true;
                    --c;
                }                
            }
            
            // Now, there should be the same number of rows & cols out of sync.
            // So, fix them by pairing them.
            for( int i=0; i<n; i++ )for( int j=0; j<m; j++ )
            {
                if( !rowok[i] && !colok[j] )
                {
                    matrix[i][j] = '0';
                    rowok[i] = true;
                    colok[j] = true;
                }
            }
        }
        
        // That's it. Now, print the answer.
        if( solved )
        {
            for( int i=0; i<n; i++ ) ps.println( new String( matrix[i] )  );   
        }
        else ps.println( -1 );
    }
        
    /**
     * main
     * 
     * @param args
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        new recovery_vanb().doit();
    }

}