In Berland each high school student is characterized by academic performance — integer value between 1 and 5.

In high school 0xFF there are two groups of pupils: the group A and the group B. Each group consists of exactly n students. An academic performance of each student is known — integer value between 1 and 5.

The school director wants to redistribute students between groups so that each of the two groups has the same number of students whose academic performance is equal to 1, the same number of students whose academic performance is 2 and so on. In other words, the purpose of the school director is to change the composition of groups, so that for each value of academic performance the numbers of students in both groups are equal.

To achieve this, there is a plan to produce a series of exchanges of students between groups. During the single exchange the director selects one student from the class A and one student of class B. After that, they both change their groups.

Print the least number of exchanges, in order to achieve the desired equal numbers of students for each academic performance.

Input

The first line of the input contains integer number n (1 ≤ n ≤ 100) — number of students in both groups.

The second line contains sequence of integer numbers a1, a2, ..., an (1 ≤ ai ≤ 5), where ai is academic performance of the i-th student of the group A.

The third line contains sequence of integer numbers b1, b2, ..., bn (1 ≤ bi ≤ 5), where bi is academic performance of the i-th student of the group B.

Output

Print the required minimum number of exchanges or -1, if the desired distribution of students can not be obtained.

Examples

Input

4
5 4 4 4
5 5 4 5


Output

1


Input

6
1 1 1 1 1 1
5 5 5 5 5 5


Output

3


Input

1
5
3


Output

-1


Input

9
3 2 5 5 2 3 3 3 2
4 1 4 1 1 2 4 4 1


Output

4
import java.util.*;
import java.math.*;
import java.io.*;
public class Luck{
	public static InputReader sc;
    public static PrintWriter out;
    public static final long MOD = (long) (1e9 + 7);
    public static void main(String[] args){
    	sc=new InputReader(System.in);	
    	out=new PrintWriter(System.out);
    	int n=sc.nextInt();
    	int[] countA=new int[6];
    	int[] countB=new int[6];
    	int[] A=new int[n];
    	int[] B=new int[n];
    	for(int i=0;i<n;i++){
    		A[i]=sc.nextInt();
    		countA[A[i]]+=1;
    		
    	}
    	for(int i=0;i<n;i++){
    		B[i]=sc.nextInt();
    		countB[B[i]]+=1;
    	}
    	int valA=0;
    	int valB=0;
    	int flag=0;
    	for(int i=1;i<=5;i++){
    		if(countA[i]==countB[i]){
    			continue;
    		}
    		if((countA[i]+countB[i])%2==1){
    			flag=1;
    			break;
    		}
    		else{
    			if(countA[i]>countB[i]){
    				valB+=((countA[i]+countB[i])/2)-countB[i];
    			}
    			else{
    				valA+=((countA[i]+countB[i])/2)-countA[i];
    			}
    		}
    	}
    	if(flag==0 && valA==valB){
    		out.println(valA);
    	}
    	else{
    		out.println(-1);
    	}
    	out.close();
    }
  
    static class Pair{
    	int u;
    	int v;
    	Pair(){
    		this.u=-1;
    		this.v=-1;
    	}
    	Pair(int u,int v){
    		this.u=u;
    		this.v=v;
    	}
    	public static Comparator<Pair> Val=new Comparator<Pair>(){
    		public int compare(Pair p1,Pair p2){
    			return (int)p1.u-(int)p2.u;
    		}
    	};
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + u;
    		result = prime * result + v;
    		return result;
    	}
    	public boolean equals(Object obj){
    		if (this == obj)
    	        return true;
    	    if (!(obj instanceof Pair)) {
    	        return false;
    	    }
    	 
    	    Pair p = (Pair) obj;
    	    if(p.u!=this.u){
    	    	return false;
    	    }
    	    else if(p.v!=p.v){
    	    	return false;
    	    }
    	    return true;
    	}
    }
//    static int val;
//    static class DisjointSet{
//    	int n;
//    	int[] par;
//    	int[] rank;
//    	DisjointSet(int n){
//    		this.n=n;
//    		this.par=new int[n];
//    		this.rank=new int[n];
//    		makeSet();
//    	}
//    	void makeSet(){
//    		for(int i=1;i<n;i++){
//    			par[i]=i;
//    			rank[i]=1;
//    		}
//    	}
//    	void union(int x,int y){
//    		int parX=parent(x);
//    		int parY=parent(y);
//    		if(parX!=parY){
//    			if(rank[parX]>=rank[parY]){
//    				rank[parX]+=rank[parY];
//    				rank[parY]=0;
//    				par[parY]=parX;
//    			}
//    			else{
//    				rank[parY]+=rank[parX];
//    				rank[parX]=0;
//    				par[parX]=parY;
//    			}
//    			val-=1;
//    		}
//    	}
//    	int parent(int c){
//    		int i=c;
//    		while(i!=par[i]){
//    			i=par[i];
//    		}
//    		return i;
//    	}
//    }
    static int gcd(int a,int b){
    	if(b==0){
    		return a;
    	}
    	return gcd(b,a%b);
    	
    }
    static int lcm(int a,int b){
    	int g;
    	if(a<b){
    		g=gcd(b,a);
    	}
    	else{
    		g=gcd(a,b);
    	}
    	return (a*b)/g;
    }
    static long bigmod ( long a, long p, long m ) {
        long res = 1 % m, x = a % m;
        while ( p>0 ) {
            if ( (p & 1)==1 ) res = ( res * x ) % m;
            x = ( x * x ) % m; p >>= 1;
        }
        return res;
    }
    static boolean isPrime(int n){
    	 if (n == 2)
    	        return true;
    	    for (long i = 2; i * i <= n; i++) {
    	        if (n % i == 0)
    	            return false;
    	    }
    	    return true;
    }
    
    static void shuffle(int[] A){
    	for(int i=A.length-1;i>0;i--){
    		int j=(int)(Math.random()*(i+1));
    		int temp=A[j];
    		A[j]=A[i];
    		A[i]=temp;
    	}
    }
    
	public static class Node implements Comparable<Node>{
	    int u;
	    int v;
	    public Node(){
	    	;
	    }
	    public Node (int u, int v) {
	    	this.u = u;
	        this.v = v;
	    }
	    
	    public void print() {
	        out.println(v + " " + u + " ");
	    }
	   
	    public int compareTo(Node n1){
	    	return this.u-n1.u;
	    }
	}
	public static long pow(long base,long exp,long mod){
		if(exp==0){
			return 1;
		}
		if(exp==1){
			return base;
		}
		long temp=exp/2;
		long val=pow(base,temp,mod);
		long result=val*val;
		result=(result%mod);
		long AND=exp&1;
		if(AND==1){
			result*=base;
			result=(result%mod);
		}
		return result;
	}
	public static BigInteger pow(BigInteger base, BigInteger exp) {
	    if(exp.equals(new BigInteger(String.valueOf(0)))){
	        return new BigInteger(String.valueOf(1));
	    }    
	    if(exp.equals(new BigInteger(String.valueOf(1))))
	        return base;
	    BigInteger temp=exp.divide(new BigInteger(String.valueOf(2)));
	    BigInteger val = pow(base, temp);
	    BigInteger result = val.multiply(val);
	    result=result.remainder(new BigInteger(String.valueOf(MOD)));
	    BigInteger AND=exp.and(new BigInteger(String.valueOf(1)));
	    if(AND.equals(new BigInteger(String.valueOf(1)))){
	        result = result.multiply(base);
	        result=result.remainder(new BigInteger(String.valueOf(MOD)));
	    }    
	    return result;
	}
	    
	static class InputReader {

	    private InputStream stream;
	    private byte[] buf = new byte[8192];
	    private int curChar, snumChars;
	    private SpaceCharFilter filter;

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

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

	    public int nextInt() {
	        int c = snext();
	        while (isSpaceChar(c))
	            c = snext();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = snext();
	        }
	        int res = 0;
	        do {
	            if (c < '0' || c > '9')
	                throw new InputMismatchException();
	            res *= 10;
	            res += c - '0';
	            c = snext();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public long nextLong() {
	        int c = snext();
	        while (isSpaceChar(c))
	            c = snext();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = snext();
	        }
	        long res = 0;
	        do {
	            if (c < '0' || c > '9')
	                throw new InputMismatchException();
	            res *= 10;
	            res += c - '0';
	            c = snext();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public int[] nextIntArray(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i < n; i++)
	            a[i] = nextInt();
	        return a;
	    }

	    public String readString() {
	        int c = snext();
	        while (isSpaceChar(c))
	            c = snext();
	        StringBuilder res = new StringBuilder();
	        do {
	            res.appendCodePoint(c);
	            c = snext();
	        } while (!isSpaceChar(c));
	        return res.toString();
	    }

	    public boolean isSpaceChar(int c) {
	        if (filter != null)
	            return filter.isSpaceChar(c);
	        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    }

	    public interface SpaceCharFilter {
	        public boolean isSpaceChar(int ch);
	    }
	}

}

