Problem: Marina loves strings of the same length and Vasya loves when there is a third string, different from them in exactly t characters. Help Vasya find at least one such string.

More formally, you are given two strings s1, s2 of length n and number t. Let's denote as f(a, b) the number of characters in which strings a and b are different. Then your task will be to find any string s3 of length n, such that f(s1, s3) = f(s2, s3) = t. If there is no such string, print  - 1.

Input

The first line contains two integers n and t (1 ≤ n ≤ 105, 0 ≤ t ≤ n).

The second line contains string s1 of length n, consisting of lowercase English letters.

The third line contain string s2 of length n, consisting of lowercase English letters.

Output

Print a string of length n, differing from string s1 and from s2 in exactly t characters. Your string should consist only from lowercase English letters. If such string doesn't exist, print -1.

Examples

Input

3 2
abc
xyc


Output

ayd

Input

1 0
c
b


Output

-1

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.InputMismatchException;

public class MarynaAndVasya {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] nt = br.readLine().split(" ");
		int n = Integer.parseInt(nt[0]);
		int t = Integer.parseInt(nt[1]);
		String[] s = {br.readLine(), br.readLine()};
		int[] equalLeft = { n-t, n-t };
		char[] result = new char[n];
		for (int i = 0; i < n; ++i) {
			if (s[0].charAt(i) == s[1].charAt(i) && equalLeft[0] > 0) {
				result[i] = s[0].charAt(i);
				--equalLeft[0];
				--equalLeft[1];
			}
		}
		for (int i = 0; i < n; ++i) {
			for( int j = 0; j < 2 && result[i] == 0; ++j) {
				if (equalLeft[j] > 0) {
					--equalLeft[j];
					result[i] = s[j].charAt(i);
				}
			}
			if (result[i] == 0) {
				for (result[i] = 'a'; result[i] == s[0].charAt(i) || result[i] == s[1].charAt(i); ++ result[i]);
			}
		}
		
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		if (equalLeft[0] > 0 || equalLeft[1] > 0) {
			bw.write("-1");
		} else {
			String resultS = new String(result);
			bw.write(resultS);
		}
		bw.flush();
	}

}


class InputReader {
    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public static boolean isSpace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public int read() {
        if (count == -1) {
            throw new InputMismatchException();
        }
        try {
            if (cur >= count) {
                cur = 0;
                count = stream.read(buffer);
                if (count <= 0)
                    return -1;
            }
        } catch (IOException e) {
            throw new InputMismatchException();
        }
        return buffer[cur++];
    }

    public int readSkipSpace() {
        int c;
        do {
            c = read();
        } while (isSpace(c));
        return c;
    }

    public long nextLong() {
        int sgn = 1;
        int c = readSkipSpace();
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9') {
                throw new InputMismatchException();
            }
            res = res * 10 + c - '0';
            c = read();
        } while (!isSpace(c));
        res *= sgn;
        return res;
    }
    
    public int nextInt(){return (int)nextLong();}
    
    public String nextString() {
    	String result = "";
    	int c = readSkipSpace();
    	do {
    		result += (char) c;
    		c = read();
    	} while(!isSpace(c));
    	return result;
    }

}


class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0) {
                writer.print(' ');
            }
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

}

class Pair <T1, T2> implements Comparable<Pair < T1, T2>> {
	public T1 first;
	public T2 second;
	public Pair(T1 first, T2 second) {
		this.first = first;
		this.second = second;
	}
	@SuppressWarnings("unchecked")
	@Override
	public int compareTo(Pair<T1, T2> arg0) {
		int firstCompare = ((Comparable<T1>)first).compareTo(arg0.first);
		return firstCompare == 0 ? ((Comparable<T2>)second).compareTo(arg0.second) : firstCompare;
	}
	
}

class Algorithm {
	@SuppressWarnings({ "rawtypes", "unchecked" })
	static Comparable maxElement(Comparable[] array) {
		Comparable result = array[0];
		for (Comparable element : array) {
			if (result.compareTo(element) < 0) {
				result = element;
			}
		}
		return result;
	}
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static int lowerBoundIndex(Comparable[] array, int first, int last, Comparable value) {
		int count = last-first;
		while (count>0) { 
			int step = count / 2;
			int index = first+step;
			if (array[index].compareTo(value) < 0) {
				first = ++index;
				count -= step+1;
			} else {
				count = step;
			}
		}
		return first;
	}
	
	@SuppressWarnings("rawtypes")
	public static int lowerBoundIndex(Comparable[] array, Comparable value) {
		return lowerBoundIndex(array, 0, array.length, value);
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static int upperBoundIndex(Comparable[] array, int first, int last, Comparable value) {
		int count = last-first;
		while (count>0) { 
			int step = count / 2;
			int index = first+step;
			if (value.compareTo(array[index]) >= 0) {
				first = ++index;
				count -= step+1;
			} else {
				count = step;
			}
		}
		return first;
	}
	
	@SuppressWarnings("rawtypes")
	public static int upperBoundIndex(Comparable[] array, Comparable value) {
		return upperBoundIndex(array, 0, array.length, value);
	}

	
}