import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class Main {
    
    // http://stackoverflow.com/questions/187676/java-equivalents-of-c-sharp-string-format-and-string-join
    private static String join(Collection<?> s, String delimiter) {
        StringBuilder builder = new StringBuilder();
        Iterator<?> iter = s.iterator();
        while (iter.hasNext()) {
            builder.append(iter.next());
            if (!iter.hasNext()) {
              break;                  
            }
            builder.append(delimiter);
        }
        return builder.toString();
    }
    
    private static <T> String join(T[] s, String delimiter){
        return join(Arrays.asList(s), delimiter);
    }
    
    @SuppressWarnings("unused")
    private static Integer[] union(Integer[] a1, Integer[] a2){
        HashSet<Integer> u = new HashSet<Integer>();
        u.addAll(Arrays.asList(a1));
        u.addAll(Arrays.asList(a2));
        
        return u.toArray(new Integer[u.size()]);
    }
    
    private static Integer[] intersect(Integer[] a1, Integer[] a2){
        HashSet<Integer> u = new HashSet<Integer>();
        u.addAll(Arrays.asList(a1));
        u.retainAll(Arrays.asList(a2));
        
        return u.toArray(new Integer[u.size()]);
    }  
    
    private static Integer[] findIndexs(Integer[] s, Integer e){
        List<Integer> lst = new ArrayList<Integer>();
        for (int i=0; i<s.length; i++){
            if (s[i] == e){
                lst.add(i);
            }
        }
        
        return lst.toArray(new Integer[lst.size()]);
    }
    
    private static GuestResult guest_4(Integer[] s1, Integer[] s2){
        Integer[] int_s1_s2 = intersect(s1, s2);
        int_s1_s2 = Arrays.asList(int_s1_s2).toArray(new Integer[]{null,null,null,null});
        
        Integer[][] table_s1 = {
            findIndexs(s1, int_s1_s2[0]), 
            findIndexs(s1, int_s1_s2[1]), 
            findIndexs(s1, int_s1_s2[2]), 
            findIndexs(s1, int_s1_s2[3])
        };
        
        Integer[][] table_s2 = {
            findIndexs(s2, int_s1_s2[0]), 
            findIndexs(s2, int_s1_s2[1]), 
            findIndexs(s2, int_s1_s2[2]), 
            findIndexs(s2, int_s1_s2[3])
        };
        
        Integer[] count_a = {
            intersect(table_s1[0], table_s2[0]).length,
            intersect(table_s1[1], table_s2[1]).length,
            intersect(table_s1[2], table_s2[2]).length,
            intersect(table_s1[3], table_s2[3]).length
        };
        
        Integer[] count_b = {
            Math.min(table_s1[0].length, table_s2[0].length) - count_a[0],
            Math.min(table_s1[1].length, table_s2[1].length) - count_a[1],
            Math.min(table_s1[2].length, table_s2[2].length) - count_a[2],
            Math.min(table_s1[3].length, table_s2[3].length) - count_a[3]
        };
        
        return new GuestResult(
            count_a[0] + count_a[1] + count_a[2] + count_a[3],
            count_b[0] + count_b[1] + count_b[2] + count_b[3]
        );
    }
    
    private static Integer[] splitToInts_4(String s){
        Integer[] tmp = {0,0,0,0};
        
        int startIndex = 4 - s.length();
        
        for (int i=0; i<s.length(); i++){
            tmp[i+startIndex] = Integer.parseInt(s.substring(i, i+1));
        }
        
        return tmp;
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true){
            Integer[] s1;
            {
                String tmp;
                
                if (!scanner.hasNextInt()) break;
                tmp = scanner.next();
                if (tmp.length() > 4) break;  
                
                s1 = splitToInts_4(tmp);
            }
            
            Integer[] s2;
            {
                String tmp;
                
                if (!scanner.hasNextInt()) break;
                tmp = scanner.next();
                if (tmp.length() > 4) break;  
                
                s2 = splitToInts_4(tmp);
            }
            
            GuestResult result = guest_4(s1, s2);
            System.out.println(join(s1, "") + " " + 
                               join(s2, "") + 
                               ": " + result.count_a() + "A" +
                                      result.count_b() + "B");
        }
    }

    private static class GuestResult{
        private int _a, _b;
        
        public GuestResult(int count_a, int count_b){
            _a = count_a;
            _b = count_b;
        }
        
        public int count_a() {return _a;}
        
        public int count_b() {return _b;}
    }
}