import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;

// _ h _ r _ t r _
// _ t _ t _ s t _

public class TaskA implements Runnable {
    long m = (int)1e9+7;
    PrintWriter w;
    InputReader c;
    final int MAXN = (int)1e6 + 100;
    public void run() {
        c = new InputReader(System.in);
        w = new PrintWriter(System.out);

        int n = c.nextInt(), hamming_distance = 0;
        char[] s = c.next().toCharArray(), t = c.next().toCharArray();
        HashMap<Character, HashSet<Character>> replace = new HashMap<>();
        HashMap<Character, Integer> map = new HashMap<>();

        for(int i=0;i<n;++i) if(s[i] != t[i]) {
            HashSet<Character> temp;
            if(replace.containsKey(s[i])){
                temp = replace.get(s[i]);
                temp.add(t[i]);
            } else {
                temp = new HashSet<>();
                temp.add(t[i]);
            }
            map.put(s[i],i);
            replace.put(s[i], temp);
            hamming_distance++;
        }

        int l = -1, r = -1;
        boolean global_check = false;
        for(int i=0;i<n;i++) if(s[i] != t[i]) {
            if(replace.containsKey(t[i])) {
                HashSet<Character> indices = replace.get(t[i]);
                int ind = map.get(t[i]);
                l = i + 1;
                r = ind + 1;
                if (indices.contains(s[i])) {
                    hamming_distance -= 2;
                    global_check = true;
                    break;
                }
            }
            if(global_check) break;
        }

        if(!global_check && l!=-1) hamming_distance--;
        else if(global_check){
            for(int i=0;i<n;i++) {
                if(t[i] == s[l-1] && s[i] == t[l-1]){
                    r = i + 1;
                    break;
                }
            }
        }
        w.println(hamming_distance);
        w.println(l+" "+r);

        w.close();
    }
    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    public static void sortbyColumn(int arr[][], int col){
        Arrays.sort(arr, new Comparator<int[]>()
        {
            public int compare(int[] o1, int[] o2){
                return(Integer.valueOf(o1[col]).compareTo(o2[col]));
            }
        });

    }
    public static class DJSet {
        public int[] upper;

        public DJSet(int n) {
            upper = new int[n];
            Arrays.fill(upper, -1);
        }

        public int root(int x) {
            return upper[x] < 0 ? x : (upper[x] = root(upper[x]));
        }

        public boolean equiv(int x, int y) {
            return root(x) == root(y);
        }

        public boolean union(int x, int y) {
            x = root(x);
            y = root(y);
            if (x != y) {
                if (upper[y] < upper[x]) {
                    int d = x;
                    x = y;
                    y = d;
                }
                upper[x] += upper[y];
                upper[y] = x;
            }
            return x == y;
        }
    }
    public static int[] radixSort(int[] f)    {
        int[] to = new int[f.length];
        {
            int[] b = new int[65537];
            for(int i = 0;i < f.length;i++)b[1+(f[i]&0xffff)]++;
            for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
            for(int i = 0;i < f.length;i++)to[b[f[i]&0xffff]++] = f[i];
            int[] d = f; f = to;to = d;
        }
        {
            int[] b = new int[65537];
            for(int i = 0;i < f.length;i++)b[1+(f[i]>>>16)]++;
            for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
            for(int i = 0;i < f.length;i++)to[b[f[i]>>>16]++] = f[i];
            int[] d = f; f = to;to = d;
        }
        return f;
    }
    public void printArray(int[] a){
        for(int i=0;i<a.length;i++)
            w.print(a[i]+" ");
        w.println();
    }
    public int[] scanArrayI(int n){
        int a[] = new int[n];
        for(int i=0;i<n;i++)
            a[i] = c.nextInt();
        return a;
    }
    public long[] scanArrayL(int n){
        long a[] = new long[n];
        for(int i=0;i<n;i++)
            a[i] = c.nextLong();
        return a;
    }
    public void printArray(long[] a){
        for(int i=0;i<a.length;i++)
            w.print(a[i]+" ");
        w.println();
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

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

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            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 String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new TaskA(),"TaskA",1<<26).start();
    }
}


import java.util.*;
import java.io.*;
import java.math.*;
import java.util.HashMap;

public class Main
{
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public static void main(String args[])
    {
        Reader sc=new Reader();
        PrintWriter out=new PrintWriter(System.out);
        int n=sc.i();
        String s1=sc.s();
        String s2=sc.s();
        int pos1=-1;
        int pos2=-1;
        int arr[][][]=new int[100][100][2];
        for(int i=0;i<n;i++)
        {
            if(s1.charAt(i)!=s2.charAt(i))
            {
                if(arr[s2.charAt(i)-97][s1.charAt(i)-97][0]==1)
                {
                    pos2=i;
                    pos1=arr[s2.charAt(i)-97][s1.charAt(i)-97][1];
                    break;
                }
                arr[s1.charAt(i)-97][s2.charAt(i)-97][0]=1;
                arr[s1.charAt(i)-97][s2.charAt(i)-97][1]=i;
            }
        }
        int ham=0;
        for(int i=0;i<n;i++)
        {
            if(s1.charAt(i)!=s2.charAt(i))
            ham++;
        }
        if(pos1!=-1&&pos2!=-1)
        {
            System.out.println(ham-2);
            System.out.println(pos1+1+" "+(pos2+1));
            System.exit(0);
        }

        int arr1[][]=new int[100][2];
        int arr2[][]=new int[100][2];
        for(int i=0;i<n;i++)
        {
            if(s1.charAt(i)!=s2.charAt(i))
            {
                if(arr1[s1.charAt(i)-97][0]==1)
                {
                    pos2=i;
                    pos1=arr1[s1.charAt(i)-97][1];
                    break;
                }
                if(arr2[s2.charAt(i)-97][0]==1)
                {
                    pos2=i;
                    pos1=arr2[s2.charAt(i)-97][1];
                    break;
                }
                arr1[s2.charAt(i)-97][0]=1;
                arr1[s2.charAt(i)-97][1]=i;
                arr2[s1.charAt(i)-97][0]=1;
                arr2[s1.charAt(i)-97][1]=i;
            }
        }
        if(pos1!=-1&&pos2!=-1)
        {
            System.out.println(ham-1);
            System.out.println(pos1+1+" "+(pos2+1));
            System.exit(0);
        }
        System.out.println(ham);
        System.out.println(pos1+" "+pos2);
    }
}


							import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.InputMismatchException;
											public class Solution1 implements Runnable
											{
												static final long MAX = 1000000007L;
												static class InputReader
												{
													private InputStream stream;
													private byte[] buf = new byte[1024];
													private int curChar;
													private int numChars;
													private SpaceCharFilter filter;
													private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

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

													public int read()
													{
														if (numChars==-1)
															throw new InputMismatchException();

														if (curChar >= numChars)
														{
															curChar = 0;
															try
															{
																numChars = stream.read(buf);
															}
															catch (IOException e)
															{
																throw new InputMismatchException();
															}

															if(numChars <= 0)
																return -1;
														}
														return buf[curChar++];
													}

													public String nextLine()
													{
														String str = "";
											            try
											            {
											                str = br.readLine();
											            }
											            catch (IOException e)
											            {
											                e.printStackTrace();
											            }
											            return str;
													}
													public int nextInt()
													{
														int c = read();

														while(isSpaceChar(c))
															c = read();

														int sgn = 1;

														if (c == '-')
														{
															sgn = -1;
															c = read();
														}

														int res = 0;
														do
														{
															if(c<'0'||c>'9')
																throw new InputMismatchException();
															res *= 10;
															res += c - '0';
															c = read();
														}
														while (!isSpaceChar(c));

														return res * sgn;
													}

													public long nextLong()
													{
														int c = read();
														while (isSpaceChar(c))
															c = read();
														int sgn = 1;
														if (c == '-')
														{
															sgn = -1;
															c = read();
														}
														long res = 0;

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

													public double nextDouble()
													{
														int c = read();
														while (isSpaceChar(c))
															c = read();
														int sgn = 1;
														if (c == '-')
														{
															sgn = -1;
															c = read();
														}
														double res = 0;
														while (!isSpaceChar(c) && c != '.')
														{
															if (c == 'e' || c == 'E')
																return res * Math.pow(10, nextInt());
															if (c < '0' || c > '9')
																throw new InputMismatchException();
															res *= 10;
															res += c - '0';
															c = read();
														}
														if (c == '.')
														{
															c = read();
															double m = 1;
															while (!isSpaceChar(c))
															{
																if (c == 'e' || c == 'E')
																	return res * Math.pow(10, nextInt());
																if (c < '0' || c > '9')
																	throw new InputMismatchException();
																m /= 10;
																res += (c - '0') * m;
																c = read();
															}
														}
														return res * sgn;
													}

													public String readString()
													{
														int c = read();
														while (isSpaceChar(c))
															c = read();
														StringBuilder res = new StringBuilder();
														do
														{
															res.appendCodePoint(c);
															c = read();
														}
														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 String next()
													{
														return readString();
													}

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

												public static void main(String args[]) throws Exception
												{
													new Thread(null, new Solution1(),"Solution1",1<<26).start();
												}
												long gcd(long a, long b)
											    {
											        if (a == 0)
											            return b;

											        return gcd(b%a, a);
											    }
											    // method to return LCM of two numbers
												 long lcm(long a, long b)
												    {
												        return (a*b)/gcd(a, b);
												    }
												 int root(int a){
													 while(arr[a] != a){
														 arr[a] = arr[arr[a]];
														 a = arr[a];
													 }
													 return a;
												 }
												 void union(int a,int b){
													 int xroot = root(a);
													 int yroot = root(b);
													 if(arr[xroot] < arr[yroot]){
														 arr[xroot] = yroot;
													 }else{
														 arr[yroot] = xroot;
													 }
												 }
												 boolean find(int a,int b){
													 int roota = root(a);
													 int rootb = root(b);
													 if(roota == rootb){
														 return true;
													 }else{
														 return false;
													 }
												 }
												 int[] arr;
												 final int level = 20;

												public void run()
												{
													InputReader sc= new InputReader(System.in);
													PrintWriter w= new PrintWriter(System.out);
													int n = sc.nextInt();
													char[] ch = new char[n];
													char[] ch2 = new char[n];
													ch = sc.next().toCharArray();
													ch2 = sc.next().toCharArray();
													HashSet<Integer> hset[] = new HashSet[26];
													for(int i = 0;i < 26;i++){
														hset[i]  =new HashSet();
													}
													int count = 0;
													for(int i = 0;i < ch.length;i++){
														if(ch[i] != ch2[i]){
															hset[ch[i]-97].add(ch2[i]-97);
															count++;
														}
													}
													boolean flag = false;
													int swap1 = -1;
													int swap2 = -1;
													int rem = -1;
													for(int i = 0;i < ch.length;i++){
														if(ch[i] != ch2[i]){
															if(hset[ch2[i]-97].size() != 0){
																swap1 = i;
																flag = true;
																if(hset[ch2[i]-97].contains(ch[i]-97)){
																	rem = i;
																	count-=2;
																	flag = false;
																	break;
																}
															}
														}
													}
													if(flag){
														count--;
														w.println(count);
														for(int i = 0;i < n;i++){
															if(i != swap1 && ch[i] == ch2[swap1] && ch[i] != ch2[i]){
																w.println((swap1+1) + " " + (i+1));
																w.close();
																System.exit(0);
															}
														}
													}else{
														if(rem == -1){
															w.println(count);
															w.println("-1 -1");
														}else{
															w.println(count);
															for(int i = 0;i < n;i++){
																if(i != rem && ch[i] == ch2[rem] && ch[rem] == ch2[i] && ch[i] != ch2[i]){
																	w.println((rem+1) + " " + (i+1));
																	w.close();
																	System.exit(0);
																}
															}
														}
													}
													w.close();
												}
												boolean fun(long[] prefix,long mid,long temp,long[] arr){
													if(temp >= prefix[(int)mid]){
														return true;
													}
													return false;
												}
												static class Pair implements Comparable<Pair>{
													int x;
													int y;

													Pair(){}
													Pair(int x,int y){
														this.x = x;
														this.y = y;

													}
													public int compareTo(Pair p){

														return Long.compare(this.x,p.x);
													}
												}
								}


import java.util.*;

public class ErrorCorrectSystem
{

	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		String a = scan.next();
		String b = scan.next();

		int[][] mismatch = new int[26][26];
		for(int i = 0; i < 26; i++) Arrays.fill(mismatch[i], -1);
		int[][] pair = new int[2][26];
		for(int i = 0; i < 2; i++) Arrays.fill(pair[i], -1);
		int hd = 0;
		for(int i = 0; i < n; i++) {
			if(a.charAt(i) != b.charAt(i)) {
				hd++;
				mismatch[a.charAt(i)-'a'][b.charAt(i)-'a'] = i;
				pair[0][a.charAt(i)-'a'] = i;
				pair[1][b.charAt(i)-'a'] = i;
			}
		}
		for(int i = 0; i < 26; i++) {
			for(int j = i+1; j < 26; j++) {
				if(mismatch[i][j] > -1 && mismatch[j][i] > -1) {
					System.out.println(hd-2);
					System.out.println((mismatch[i][j]+1)+" "+(mismatch[j][i]+1));
					return;
				}
			}
		}
		for(int i = 0; i < n; i++) {
			if(a.charAt(i) != b.charAt(i)) {
				//try a gets b's letter
				if(pair[0][b.charAt(i)-'a'] > -1) {
					System.out.println(hd-1);
					System.out.println((i+1)+" "+(pair[0][b.charAt(i)-'a']+1));
					return;
				}
			}
		}

		System.out.println(hd);
		System.out.println("-1 -1");
	}

}


import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class C {
    public static void main(String[] args) throws Exception {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        // Scanner scan = new Scanner(System.in);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        int n = Integer.parseInt(bf.readLine());
        int counter = 0;
        for(int i=0; i<2*n/3; i++) System.out.println("0 " + i);
        for(int i=0; i<n-2*n/3; i++) System.out.println("3 " + (2*i+1));

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
744444444747477777774
44444447474747777777
 */

/**
 *
 * @author Andy Phan
 */
public class b {
    public static void main(String[] args) {
        FS in = new FS(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        Integer[] arr = new Integer[n];
        int numZ = 0;
        for(int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
            if(arr[i] == 0) numZ++;
        }

        Arrays.sort(arr);

        if(numZ > 1) {
            System.out.println("cslnb");
            return;
        }
        int numDup = 0;
        int[] arr2 = new int[n];
        for(int i = 0; i < n; i++) {
            arr2[i] = arr[i];
            if(i != 0) {
                if(arr2[i] == arr2[i-1]) {
                    arr2[i-1]--;
                    numDup++;
                }
            }
        }

        if(numDup > 1) {
            System.out.println("cslnb");
            return;
        }

        for(int i = 0; i < n; i++) {
            if(i != 0) {
                if(arr2[i] == arr2[i-1]) {
                    System.out.println("cslnb");
                    return;
                }
            }
        }
        long num = 0;
        if(numDup == 1) num++;
        for(int i = 0; i < n; i++) {
            num += arr2[i]-i;
        }

        if(num%2 == 0) {
            System.out.println("cslnb");
        } else {
            System.out.println("sjfnb");
        }

        out.close();
    }

    static class FS {

        BufferedReader in;
        StringTokenizer token;

        public FS(InputStream str) {
            in = new BufferedReader(new InputStreamReader(str));
        }

        public String next() {
            if (token == null || !token.hasMoreElements()) {
                try {
                    token = new StringTokenizer(in.readLine());
                } catch (IOException ex) {
                }
                return next();
            }
            return token.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}


import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class temp
{

	void solve()
	{
		FastReader sc =new FastReader();
		int n = sc.nextInt();

		ArrayList<String> a[] = new ArrayList[5];

		for(int i=0;i<=4;i++)
			a[i] = new ArrayList<>();

		for(int i=0;i<n;i++)
		{
			String s = sc.next();
			a[s.length()].add(s);
		}

		int ans = 0;

		for(int i=0;i<n;i++)
		{
			String s = sc.next();
			if(a[s.length()].contains(s))
				a[s.length()].remove(new String(s));
		}

		for(int i=1;i<=4;i++)
			ans+=a[i].size();

		System.out.println(ans);
	}

    public static void main(String[] args)
    {
        new temp().solve();
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}


import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;
import java.util.Map.Entry;

public class Main {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
	private PrintWriter pw;
	private long mod = 1000000000 + 7;

	private StringBuilder ans_sb;
	private int size = 1000005;
	private long[] fact;
	private void soln() {
		int n = nextInt();
		HashMap<String, Integer>[] s1 = new HashMap[4];
		for(int i=0;i<=3;i++) {
			s1[i] = new HashMap<>();
		}
		int cnt = 0;
		for(int i=0;i<n;i++) {
			String s = nextLine();
			if(s1[s.length()-1].containsKey(s)) {
				s1[s.length()-1].put(s, s1[s.length()-1].get(s)+1);
			}else
				s1[s.length()-1].put(s, 1);
		}
		for(int i=0;i<n;i++) {
			String s = nextLine();
			if(s1[s.length()-1].containsKey(s)) {
				s1[s.length()-1].put(s, s1[s.length()-1].get(s)-1);
				if(s1[s.length()-1].get(s) == 0)
					s1[s.length()-1].remove(s);
			}else {
				cnt++;
			}
		}
		pw.println(cnt);
	}
	private class Pair implements Comparable<Pair>{
		long x, y;
		int i;
		public Pair(long a,long b,int c) {
			x = a;
			y = b;
			i = c;
		}
		@Override
		public int compareTo(
				Pair o)
		{
			return Long.compare(this.x, o.x);
		}
		public String toString() {
			return ""+i;
		}
	}
	private void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}
	private long pow(long a, long b, long c) {
		if (b == 0)
			return 1;
		long p = pow(a, b / 2, c);
		p = (p * p) % c;
		return (b % 2 == 0) ? p : (a * p) % c;
	}

	private long gcd(long n, long l) {
		if (l == 0)
			return n;
		return gcd(l, n % l);
	}

	public static void main(String[] args) throws Exception {
		new Thread(null, new Runnable() {
			@Override
			public void run() {
				new Main().solve();
			}
		}, "1", 1 << 26).start();
		//new Main().solve();
	}

	public StringBuilder solve() {
		InputReader(System.in);
		/*
		 * try { InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
		 * } catch(FileNotFoundException e) {}
		 */
		pw = new PrintWriter(System.out);
		// ans_sb = new StringBuilder();
		soln();

		pw.close();
		// System.out.println(ans_sb);
		return ans_sb;
	}

	public void InputReader(InputStream stream1) {
		stream = stream1;
	}

	private boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

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

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

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

	private String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

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

	private long[] nextLongArray(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextLong();
		}
		return arr;
	}

	private void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private char nextChar() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(c))
			c = read();
		return c1;
	}

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


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Map;
import java.util.HashMap;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author bacali
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ACodehorsesTShirts solver = new ACodehorsesTShirts();
        solver.solve(1, in, out);
        out.close();
    }

    static class ACodehorsesTShirts {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            Map<String, Integer> map = new HashMap<>();
            for (int i = 0; i < n; i++) {
                String ch = in.next();
                if (map.containsKey(ch)) {
                    map.put(ch, map.get(ch) + 1);
                } else {
                    map.put(ch, 1);
                }
            }
            int s = n;
            for (int i = 0; i < n; i++) {
                String ch = in.next();
                if (map.containsKey(ch)) {
                    if (map.get(ch) == 1) {
                        map.remove(ch);
                    } else {
                        map.put(ch, map.get(ch) - 1);
                    }
                    s--;
                }
            }
            out.println(s);
        }

    }

    static class FastScanner {
        private BufferedReader br;
        private StringTokenizer st;

        public FastScanner(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    static BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tok;
    static boolean hasNext()
    {
        while(tok==null||!tok.hasMoreTokens())
            try{
                tok=new StringTokenizer(in.readLine());
            }
            catch(Exception e){
                return false;
            }
        return true;
    }
    static String next()
    {
        hasNext();
        return tok.nextToken();
    }
    static long nextLong()
    {
        return Long.parseLong(next());
    }
    static int nextInt()
    {
        return Integer.parseInt(next());
    }
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));

    public static void main(String[] args) {
        int n = nextInt();
        int a[] = new int[9];
        int b[] = new int[9];
        for(int i=0;i<n;i++){
            String s = next();
            if(s.equals("M")){
                a[0]++;
            }else if (s.equals("L")){
                a[1]++;
            }
            else if (s.equals("XL")){
                a[2]++;
            }
            else if (s.equals("XXL")){
                a[3]++;
            }
            else if (s.equals("XXXL")){
                a[4]++;
            }
            else if (s.equals("S")){
                a[5]++;
            }
            else if (s.equals("XS")){
                a[6]++;
            }
            else if (s.equals("XXS")){
                a[7]++;
            }
            else if (s.equals("XXXS")){
                a[8]++;
            }
        }
        for(int i=0;i<n;i++){
            String s = next();
            if(s.equals("M")){
                b[0]++;
            }else if (s.equals("L")){
                b[1]++;
            }
            else if (s.equals("XL")){
                b[2]++;
            }
            else if (s.equals("XXL")){
                b[3]++;
            }
            else if (s.equals("XXXL")){
                b[4]++;
            }
            else if (s.equals("S")){
                b[5]++;
            }
            else if (s.equals("XS")){
                b[6]++;
            }
            else if (s.equals("XXS")){
                b[7]++;
            }
            else if (s.equals("XXXS")){
                b[8]++;
            }
        }

        int ans = 0;
        ans+=Math.abs(a[2]-b[2]);
        ans+=Math.abs(a[3]-b[3]);
        ans+=Math.abs(a[4]-b[4]);
        int max = Math.abs(a[0]-b[0]);
        max = max(max,Math.abs(a[1]-b[1]));
        max = max(max,Math.abs(a[5]-b[5]));
        ans+=max;
        out.print(ans);
        out.flush();
    }
    public static int max(int a,int b){
        return a>b?a:b;
    }
}


import java.util.*;
public class hackerearth {

    public  static  void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();

        HashMap<String,Integer> map=new HashMap<>();
        HashMap<String,Integer> map2=new HashMap<>();
        for(int i=0;i<n;i++)
        {
            String s=sc.next();
            if(map.containsKey(s))
                map.put(s,map.get(s)+1);
            else
                map.put(s,1);
        }
        for(int i=0;i<n;i++)
        {
            String s=sc.next();
            if(map2.containsKey(s))
                map2.put(s,map2.get(s)+1);
            else
                map2.put(s,1);

            if(map.containsKey(s)) {
                int feq = map.get(s);
                feq--;
                if (feq <= 0)
                    map.remove(s);
                else
                    map.put(s, feq);
            }

        }

        int ans=0;
        for(Map.Entry<String,Integer> entry:map.entrySet())
        {
            ans+=entry.getValue();
        }
        System.out.println(ans);

    }

}


import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.InputMismatchException;

public class E46A
{
	public static void main(String[] args)
	{
		FastScanner in = new FastScanner(System.in);
		String[] sizes = {"XXXS", "XXS", "XS", "S", "M", "L", "XL", "XXL", "XXXL"};
		int n = in.nextInt();
		HashMap<String, Integer> a = new HashMap<>();
		HashMap<String, Integer> b = new HashMap<>();
		for (String s : sizes) {
			a.put(s, 0);
			b.put(s, 0);
		}
		for (int i = 0; i < n; i++) {
			String s = in.next();
			a.put(s, a.get(s) + 1);
		}
		for (int i = 0; i < n; i++) {
			String s = in.next();
			b.put(s, b.get(s) + 1);
		}
		for (String s : sizes) {
			int cut = Math.min(a.get(s), b.get(s));
			a.put(s, a.get(s) - cut);
			b.put(s, b.get(s) - cut);
		}
		int changes = 0;
		for (String s : sizes)
			changes += a.get(s);
		System.out.println(changes);
	}

	/**
	 * Source: Matt Fontaine
	 */
	public static class FastScanner
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

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

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

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

		boolean isEndline(int c)
		{
			return c == '\n' || c == '\r' || c == -1;
		}

		public int nextInt()
		{
			return Integer.parseInt(next());
		}

		public long nextLong()
		{
			return Long.parseLong(next());
		}

		public double nextDouble()
		{
			return Double.parseDouble(next());
		}

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

		public String nextLine()
		{
			int c = read();
			while (isEndline(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			} while (!isEndline(c));
			return res.toString();
		}
	}
}


import java.util.*;
import java.io.*;

// Solution

public class Main
{
  public static void main (String[] argv)
  {
	  new Main();
  }

  boolean test = false;

  public Main()  {
	  FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
	  //FastReader in = new FastReader(new BufferedReader(new FileReader("Main.in")));
      int n = in.nextInt();
      int nM = 0;
      int[] nS = new int[4];
      int[] nL = new int[4];
      for (int i = 0; i < n; i++) {
          String s = in.next();
          int ns = s.length();
          if (s.charAt(0) == 'M') nM++;
          else if (s.charAt(ns - 1) == 'S') nS[ns-1]++;
          else nL[ns-1]++;
      }
      int c = 0;
      int[] nSr = new int[4];
      int[] nLr = new int[4];
      int nMr = 0;
      for (int i = 0; i < n; i++) {
          String s = in.next();
          int ns = s.length();
          if (s.charAt(0) == 'M') {
              if (nM > 0) --nM;
              else ++nMr;
          }else if (s.charAt(ns - 1) == 'S') {
              if (nS[ns-1] > 0) --nS[ns-1];
              else ++nSr[ns-1];
          }else {
              if (nL[ns-1] > 0) --nL[ns-1];
              else ++nLr[ns-1];
          }
      }

      for (int i = 0; i < 4; i++) c += nS[i] + nL[i];
      c += nM;

      System.out.println(c);
  }

  private int nBit1(int v) {
      int v0 = v;
      int c = 0;
      while (v != 0) {
          ++c;
          v = v & (v - 1);
      }
      return c;
  }

  private int common(int v) {
      int c = 0;
      while (v != 1) {
          v = (v >>> 1);
          ++c;
      }

      return c;
  }

  private void reverse(char[] a, int i, int j) {
      while (i < j) {
          swap(a, i++, j--);
      }
  }

  private void swap(char[] a, int i, int j) {
      char t = a[i];
      a[i] = a[j];
      a[j] = t;
  }

  private long gcd(long x, long y) {
      if (y == 0) return x;
      return gcd(y, x % y);
  }
  private int max(int a, int b) {
      return a >  b ? a : b;
  }

  private int min(int a, int b) {
      return a >  b ? b : a;
  }

  static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader(BufferedReader in)
        {
            br = in;
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    String line = br.readLine();
                    if (line == null || line.length() == 0) return "";
                    st = new StringTokenizer(line);
                }
                catch (IOException  e)
                {
                    return "";
                    //e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                return "";
                //e.printStackTrace();
            }
            return str;
        }
    }
}


import java.util.ArrayList;
import java.util.Scanner;
import java.lang.StringBuilder;
import java.util.Arrays;
import java.util.Stack;
import java.util.TreeMap;
public class Test11   {
    public static void main(String[] Args)   {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s0 = sc.nextLine();
        int s = 0; // S
        int m = 0;
        int l = 0;
        int s1 = 0;
        int l1 = 0;
        int s2 = 0;
        int l2 = 0;
        int s3 = 0;
        int l3 = 0;
        for (int i = 0; i < n; i++)  {
            s0 = sc.nextLine();
            if (s0.charAt(0) == 'S') s++;
            if (s0.charAt(0) == 'M') m++;
            if (s0.charAt(0) == 'L') l++;
            if (s0.charAt(0) == 'X' && s0.length() == 2 && s0.charAt(s0.length() - 1) == 'S') s1++;
            if (s0.charAt(0) == 'X' && s0.length() == 3 && s0.charAt(s0.length() - 1) == 'S') s2++;
            if (s0.charAt(0) == 'X' && s0.length() == 4 && s0.charAt(s0.length() - 1) == 'S') s3++;
            if (s0.charAt(0) == 'X' && s0.length() == 2 && s0.charAt(s0.length() - 1) == 'L') l1++;
            if (s0.charAt(0) == 'X' && s0.length() == 3 && s0.charAt(s0.length() - 1) == 'L') l2++;
            if (s0.charAt(0) == 'X' && s0.length() == 4 && s0.charAt(s0.length() - 1) == 'L') l3++;
        }
        int rs = 0; // S
        int rm = 0;
        int rl = 0;
        int rs1 = 0;
        int rl1 = 0;
        int rs2 = 0;
        int rl2 = 0;
        int rs3 = 0;
        int rl3 = 0;
        for (int i = 0; i < n; i++)  {
            s0 = sc.nextLine();
            if (s0.charAt(0) == 'S') rs++;
            if (s0.charAt(0) == 'M') rm++;
            if (s0.charAt(0) == 'L') rl++;
            if (s0.charAt(0) == 'X' && s0.length() == 2 && s0.charAt(s0.length() - 1) == 'S') rs1++;
            if (s0.charAt(0) == 'X' && s0.length() == 3 && s0.charAt(s0.length() - 1) == 'S') rs2++;
            if (s0.charAt(0) == 'X' && s0.length() == 4 && s0.charAt(s0.length() - 1) == 'S') rs3++;
            if (s0.charAt(0) == 'X' && s0.length() == 2 && s0.charAt(s0.length() - 1) == 'L') rl1++;
            if (s0.charAt(0) == 'X' && s0.length() == 3 && s0.charAt(s0.length() - 1) == 'L') rl2++;
            if (s0.charAt(0) == 'X' && s0.length() == 4 && s0.charAt(s0.length() - 1) == 'L') rl3++;
        }
        int ans = Math.abs(s1 - rs1) + Math.abs(s2 - rs2) + Math.abs(s3 - rs3) + (Math.abs(s - rs) + Math.abs(l - rl) + Math.abs(m - rm))/2;
        System.out.println(ans);

   }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Edu_46A {

	public static void main(String[] args) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter printer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int nE = Integer.parseInt(reader.readLine());

		int[][] cnt = new int[][] { { 0, 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };

		for (int i = 0; i < nE; i++) {
			String nxt = reader.readLine();
			if (nxt.equals("S")) {
				cnt[0][0]++;
			}
			if (nxt.equals("M")) {
				cnt[0][1]++;
			}
			if (nxt.equals("L")) {
				cnt[0][2]++;
			}
			if (nxt.equals("XS")) {
				cnt[1][0]++;
			}
			if (nxt.equals("XL")) {
				cnt[1][1]++;
			}
			if (nxt.equals("XXS")) {
				cnt[2][0]++;
			}
			if (nxt.equals("XXL")) {
				cnt[2][1]++;
			}
			if (nxt.equals("XXXS")) {
				cnt[3][0]++;
			}
			if (nxt.equals("XXXL")) {
				cnt[3][1]++;
			}
		}

		for (int i = 0; i < nE; i++) {
			String nxt = reader.readLine();
			if (nxt.equals("S")) {
				cnt[0][0]--;
			}
			if (nxt.equals("M")) {
				cnt[0][1]--;
			}
			if (nxt.equals("L")) {
				cnt[0][2]--;
			}
			if (nxt.equals("XS")) {
				cnt[1][0]--;
			}
			if (nxt.equals("XL")) {
				cnt[1][1]--;
			}
			if (nxt.equals("XXS")) {
				cnt[2][0]--;
			}
			if (nxt.equals("XXL")) {
				cnt[2][1]--;
			}
			if (nxt.equals("XXXS")) {
				cnt[3][0]--;
			}
			if (nxt.equals("XXXL")) {
				cnt[3][1]--;
			}
		}

		int ans = 0;
		for (int i = 1; i <= 3; i++) {
			ans += Math.abs(cnt[i][0]);
		}

		int max = 0;
		for (int i = 0; i < 3; i++) {
			max = Math.max(max, Math.abs(cnt[0][i]));
		}
		ans += max;
		printer.println(ans);
		printer.close();
	}
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;

public class CodehorsesT_shirts {

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(reader.readLine());
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        String input;
        for (int i = 0; i < n; i++) {
            input = reader.readLine();
            if (map.containsKey(input)) {
                map.put(input, map.get(input) + 1);
            } else {
                map.put(input, 1);
            }
        }
        int change = 0;
        for (int i = 0; i < n; i++) {
            input = reader.readLine();
            if (map.containsKey(input)) {
                map.put(input, map.get(input) - 1);
            } else {
                map.put(input, -1);
            }
        }
        for (int x : map.values()) {
            change += Math.abs(x);
        }
        System.out.println(change/2);
    }

}


import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		String[] s = {"XXXS", "XXS", "XS", "S", "M", "L", "XL", "XXL", "XXXL"};
		int[] size = new int[9];
		for(int i=0; i<N; i++){
			String c = br.readLine();
			for(int j=0; j<9; j++){
				if(s[j].equals(c)){
					size[j]++;
				}
			}
		}
		for(int i=0; i<N; i++){
			String c = br.readLine();
			for(int j=0; j<9; j++){
				if(s[j].equals(c)){
					size[j]--;
				}
			}
		}
		int sum = 0;
		for(int i=0; i<9; i++){
			if(size[i]>0)
				sum += size[i];
		}
		System.out.println(sum);
	}
}


import java.util.*;
import java.lang.*;
import java.io.*;

public class CodehorsesTShirt {

    public static void main(String args[]) throws IOException {
        FastReader in = new FastReader();
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        Task.solve(in, out);
        out.close();
    }

    static class Task {

        public static void solve(FastReader in, PrintWriter out) {
            int n = in.nextInt();
            HashMap<String , Integer> hm1 = new HashMap<>();
            HashMap<String , Integer> hm2 = new HashMap<>();

            for(int i=0;i<n;i++){
                String val = in.next();
                if(hm1.containsKey(val)){
                    hm1.put(val, hm1.get(val)+1);
                }else{
                    hm1.put(val,1);
                }
            }

            for(int i=0;i<n;i++){
                String val = in.next();
                if(hm1.containsKey(val)){
                    int x = hm1.get(val);
                    if(x==1){
                        hm1.remove(val);
                    }else{
                        hm1.put(val,hm1.get(val)-1);
                    }
                }else{
                    if(hm2.containsKey(val)){
                        hm2.put(val, hm2.get(val)+1);
                    }else{
                        hm2.put(val,1);
                    }
                }
            }
            int ans = 0;
            for(Map.Entry<String , Integer> row: hm1.entrySet()){
                ans += row.getValue();
            }
            System.out.println(ans);

        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}


import java.io.*;
import java.util.*;
/*
 * Heart beats fast
 * 		Colors and promises
 * 			How to be brave
 * 				How can I love when I am afraid...
 */
//read the question correctly (is y a vowel? what are the exact constraints?)
//look out for SPECIAL CASES (n=1?) and overflow (ll vs int?)
//always declare multidimensional arrays as [2][n] not [n][2]
//it can lead to upto 2-3x diff in runtime
//declare int/long tries with 16 array size due to object overhead :D
public class Main
{

	public static void main(String[] args) throws Exception
	{
		int n=ni();
		Map<String, Integer> hola=new HashMap<String,Integer>();
		hola.put("S", 0);
		hola.put("XS", 0);
		hola.put("XXS", 0);
		hola.put("XXXS", 0);
		hola.put("M", 0);
		hola.put("L", 0);
		hola.put("XL", 0);
		hola.put("XXL", 0);
		hola.put("XXXL", 0);
		for(int i=0; i<n; i++)
		{
			String te=ns();
			hola.put(te,hola.get(te)+1);
		}
		for(int i=0; i<n; i++)
		{
			String te=ns();
			hola.put(te,hola.get(te)-1);
		}
		int ans=0;
		for(int te:hola.values())
		{
			ans+=max(te,0);
		}
		pr(ans);
		System.out.print(output);
	}
	///////////////////////////////////////////
	///////////////////////////////////////////
	///template from here
	static int pow(int a, int b)
	{
		int c=1;
		while(b>0)
		{
			if(b%2!=0)
				c*=a;
			a*=a;
		}
		return c;
	}
	static class pair
	{
		int a, b;
		pair(){}
		pair(int c,int d){a=c;b=d;}
	}
	static interface combiner
	{
		public long combine(long a,long b);
	}
	static final long mod=1000000007;
	static final double eps=1e-9;
	static final long inf=100000000000000000L;
	static Reader in=new Reader();
	static StringBuilder output=new StringBuilder();
	static Random rn=new Random();
	static void reverse(int[]a){for(int i=0; i<a.length/2; i++){a[i]^=a[a.length-i-1];a[a.length-i-1]^=a[i];a[i]^=a[a.length-i-1];}}
	static void sort(int[]a)
	{
		int te;
		for(int i=0; i<a.length; i+=2)
		{
			te=rn.nextInt(a.length);
			if(i!=te)
			{
				a[i]^=a[te];
				a[te]^=a[i];
				a[i]^=a[te];
			}
		}
		Arrays.sort(a);
	}
	static void sort(long[]a)
	{
		int te;
		for(int i=0; i<a.length; i+=2)
		{
			te=rn.nextInt(a.length);
			if(i!=te)
			{
			a[i]^=a[te];
			a[te]^=a[i];
			a[i]^=a[te];
			}
		}
		Arrays.sort(a);
	}
	static void sort(double[]a)
	{
		int te;
		double te1;
		for(int i=0; i<a.length; i+=2)
		{
			te=rn.nextInt(a.length);
			if(i!=te)
			{
			te1=a[te];
			a[te]=a[i];
			a[i]=te1;
			}
		}
		Arrays.sort(a);
	}
	static void sort(int[][]a)
	{
		Arrays.sort(a, new Comparator<int[]>()
		{
			public int compare(int[]a,int[]b)
			{
				if(a[0]>b[0])
					return -1;
				if(b[0]>a[0])
					return 1;
				return 0;
			}
		});
	}
	static void sort(pair[]a)
	{
		Arrays.sort(a,new Comparator<pair>()
				{
			@Override
			public int compare(pair a,pair b)
			{
				if(a.a>b.a)
					return 1;
				if(b.a>a.a)
					return -1;
				return 0;
			}
				});
	}
	static int log2n(long a)
	{
		int te=0;
		while(a>0)
		{
			a>>=1;
			++te;
		}
		return te;
	}
	static class vectorl implements Iterable<Long>
	{
		long a[];
		int size;
		vectorl(){a=new long[10];size=0;}
		vectorl(int n){a=new long[n];size=0;}
		public void add(long b){if(++size==a.length)a=Arrays.copyOf(a, 2*size);a[size-1]=b;}
		public void sort(){Arrays.sort(a, 0, size);}
		public void sort(int l, int r){Arrays.sort(a, l, r);}
		@Override
		public Iterator<Long> iterator() {
			Iterator<Long> hola=new Iterator<Long>()
					{
				int cur=0;
						@Override
						public boolean hasNext() {
							return cur<size;
						}
						@Override
						public Long next() {
							return a[cur++];
						}
					};
			return hola;
		}
	}
	static class vector implements Iterable<Integer>
	{
		int a[],size;
		vector(){a=new int[10];size=0;}
		vector(int n){a=new int[n];size=0;}
		public void add(int b){if(++size==a.length)a=Arrays.copyOf(a, 2*size);a[size-1]=b;}
		public void sort(){Arrays.sort(a, 0, size);}
		public void sort(int l, int r){Arrays.sort(a, l, r);}
		@Override
		public Iterator<Integer> iterator() {
			Iterator<Integer> hola=new Iterator<Integer>()
					{
				int cur=0;
						@Override
						public boolean hasNext() {
							return cur<size;
						}
						@Override
						public Integer next() {
							return a[cur++];
						}
					};
			return hola;
		}
	}
	//output functions////////////////
	static void pr(Object a){output.append(a+"\n");}
	static void pr(){output.append("\n");}
	static void p(Object a){output.append(a);}
	static void pra(int[]a){for(int i:a)output.append(i+" ");output.append("\n");}
	static void pra(long[]a){for(long i:a)output.append(i+" ");output.append("\n");}
	static void pra(String[]a){for(String i:a)output.append(i+" ");output.append("\n");}
	static void pra(double[]a){for(double i:a)output.append(i+" ");output.append("\n");}
	static void sop(Object a){System.out.println(a);}
	static void flush(){System.out.println(output);output=new StringBuilder();}
	//////////////////////////////////
	//input functions/////////////////
	static int ni(){return Integer.parseInt(in.next());}
	static long nl(){return Long.parseLong(in.next());}
	static String ns(){return in.next();}
	static double nd(){return Double.parseDouble(in.next());}
	static int[] nia(int n){int a[]=new int[n];for(int i=0; i<n; i++)a[i]=ni();return a;}
	static int[] pnia(int n){int a[]=new int[n+1];for(int i=1; i<=n; i++)a[i]=ni();return a;}
	static long[] nla(int n){long a[]=new long[n];for(int i=0; i<n; i++)a[i]=nl();return a;}
	static String[] nsa(int n){String a[]=new String[n];for(int i=0; i<n; i++)a[i]=ns();return a;}
	static double[] nda(int n){double a[]=new double[n];for(int i=0; i<n; i++)a[i]=nd();return a;}
	//////////////////////////////////
	//some utility functions
	static void exit(){System.out.print(output);System.exit(0);}
	static int min(int... a){int min=a[0];for(int i:a)min=Math.min(min, i);return min;}
	static int max(int... a){int max=a[0];for(int i:a)max=Math.max(max, i);return max;}
	static int gcd(int... a){int gcd=a[0];for(int i:a)gcd=gcd(gcd, i);return gcd;}
	static long min(long... a){long min=a[0];for(long i:a)min=Math.min(min, i);return min;}
	static long max(long... a){long max=a[0];for(long i:a)max=Math.max(max, i);return max;}
	static long gcd(long... a){long gcd=a[0];for(long i:a)gcd=gcd(gcd, i);return gcd;}
	static String pr(String a, long b){String c="";while(b>0){if(b%2==1)c=c.concat(a);a=a.concat(a);b>>=1;}return c;}
	static long powm(long a, long b, long m){long an=1;long c=a;while(b>0){if(b%2==1)an=(an*c)%m;c=(c*c)%m;b>>=1;}return an;}
	static int gcd(int a, int b){if(b==0)return a;return gcd(b, a%b);}
	static long gcd(long a, long b){if(b==0)return a;return gcd(b, a%b);}
	static class Reader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public Reader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
    }
}


import java.io.*;
import java.util.*;

public class TaskA
{
	public static void main(String[] args)
	{
		new TaskA(System.in, System.out);
	}

	static class Solver implements Runnable
	{
		int n;
		String[] last, curr;
		BufferedReader in;
		PrintWriter out;

		void solve() throws IOException
		{
			n = Integer.parseInt(in.readLine());
			last = new String[n];
			curr = new String[n];

			for (int i = 0; i < n; i++)
				last[i] = in.readLine();

			for (int i = 0; i < n; i++)
				curr[i] = in.readLine();

			int changes = 0;
			String[] sizes = new String[]{"S", "M", "L", "XS", "XXS", "XXXS", "XL", "XXL", "XXXL"};
			int[] old = count(last, sizes);
			int[] now = count(curr, sizes);

			for (int i= 0; i < sizes.length; i++)
			{
				changes += Math.abs(old[i] - now[i]);
			}

			out.println(changes / 2);

/*			if (now[0] > old[0])
			{
				int add = now[0] - old[0];

				changes += add;

			}*/
		}

		int[] count(String[] s, String[] sizes)
		{
			int len = sizes.length;
			int[] cnt = new int[len];

			for (int i = 0; i < len; i++)
			{
				for (String str : s)
				{
					if (str.equals(sizes[i]))
						cnt[i]++;
				}
			}

			return cnt;
		}

		void debug(Object... o)
		{
			System.err.println(Arrays.deepToString(o));
		}

		public Solver(BufferedReader in, PrintWriter out)
		{
			this.in = in;
			this.out = out;
		}

		@Override
		public void run()
		{
			try
			{
				solve();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}

	}

	static class CMath
	{
		static long power(long number, long power)
		{
			if (number == 1 || number == 0 || power == 0)
				return 1;

			if (power == 1)
				return number;

			if (power % 2 == 0)
				return power(number * number, power / 2);
			else
				return power(number * number, power / 2) * number;
		}

		static long modPower(long number, long power, long mod)
		{
			if (number == 1 || number == 0 || power == 0)
				return 1;

			number = mod(number, mod);

			if (power == 1)
				return number;

			long square = mod(number * number, mod);

			if (power % 2 == 0)
				return modPower(square, power / 2, mod);
			else
				return mod(modPower(square, power / 2, mod) * number, mod);
		}

		static long moduloInverse(long number, long mod)
		{
			return modPower(number, mod - 2, mod);
		}

		static long mod(long number, long mod)
		{
			return number - (number / mod) * mod;
		}

		static int gcd(int a, int b)
		{
			if (b == 0)
				return a;
			else
				return gcd(b, a % b);
		}

		static long min(long... arr)
		{
			long min = arr[0];

			for (int i = 1; i < arr.length; i++)
				min = Math.min(min, arr[i]);

			return min;
		}

		static long max(long... arr)
		{
			long max = arr[0];

			for (int i = 1; i < arr.length; i++)
				max = Math.max(max, arr[i]);

			return max;
		}

		static int min(int... arr)
		{
			int min = arr[0];

			for (int i = 1; i < arr.length; i++)
				min = Math.min(min, arr[i]);

			return min;
		}

		static int max(int... arr)
		{
			int max = arr[0];

			for (int i = 1; i < arr.length; i++)
				max = Math.max(max, arr[i]);

			return max;
		}

	}

	static class Utils
	{
		static boolean nextPermutation(int[] arr)
		{
			for (int a = arr.length - 2; a >= 0; --a)
			{
				if (arr[a] < arr[a + 1])
				{
					for (int b = arr.length - 1; ; --b)
					{
						if (arr[b] > arr[a])
						{
							int t = arr[a];

							arr[a] = arr[b];
							arr[b] = t;

							for (++a, b = arr.length - 1; a < b; ++a, --b)
							{
								t = arr[a];
								arr[a] = arr[b];
								arr[b] = t;
							}

							return true;
						}
					}
				}
			}

			return false;
		}

	}

	public TaskA(InputStream inputStream, OutputStream outputStream)
	{
		BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
		PrintWriter out = new PrintWriter(outputStream);
		Thread thread = new Thread(null, new Solver(in, out), "TaskA", 1 << 29);

		try
		{
			thread.start();
			thread.join();
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		finally
		{
			try
			{
				in.close();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}

			out.flush();
			out.close();
		}
	}

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */
public class Main {
    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                new Main().solve();
            }
        }, "1", 1 << 26).start();
    }

    void solve() {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ACodehorsesTShirts solver = new ACodehorsesTShirts();
        solver.solve(1, in, out);
        out.close();
    }

    static class ACodehorsesTShirts {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            int n = in.scanInt();
            ArrayList<String>[] arrayLists = new ArrayList[5];
            ArrayList<String>[] arrayLists1 = new ArrayList[5];
            for (int i = 0; i < 5; i++) {
                arrayLists[i] = new ArrayList<>();
                arrayLists1[i] = new ArrayList<>();
            }
            for (int i = 0; i < n; i++) {
                String s = in.scanString();
                arrayLists[s.length()].add(s);
            }
            for (int i = 0; i < n; i++) {
                String s = in.scanString();
                arrayLists1[s.length()].add(s);
            }
            long ans = 0;
            for (int i = 0; i < 5; i++) {
                for (int diff = 0; diff < 5; diff++) {

                    for (int j = 0; j < arrayLists[i].size(); j++) {
                        int min = Integer.MAX_VALUE;
                        int index = -1;
                        for (int k = 0; k < arrayLists1[i].size(); k++) {
                            int tt = 0;
                            for (int l = 0; l < i; l++)
                                if (arrayLists[i].get(j).charAt(l) != arrayLists1[i].get(k).charAt(l)) tt++;
                            if (tt < min) {
                                min = tt;
                                index = k;
                            }

                        }
                        if (min == diff) {
                            arrayLists1[i].remove(index);
                            ans += min;
                        }
                    }
                }
            }
            out.println(ans);

        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int index;
        private BufferedInputStream in;
        private int total;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= total) {
                index = 0;
                try {
                    total = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (total <= 0) return -1;
            }
            return buf[index++];
        }

        public int scanInt() {
            int integer = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = scan();
                }
            }
            return neg * integer;
        }

        public String scanString() {
            int c = scan();
            if (c == -1) return null;
            while (isWhiteSpace(c)) c = scan();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = scan();
            } while (!isWhiteSpace(c));
            return res.toString();
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }
}


import java.util.*;
import java.io.*;
import java.text.DecimalFormat;

public class Main{
    final long mod = (int)1e9+7, IINF = (long)1e19;
    final int MAX = (int)1e6+1, MX = (int)1e7+1, INF = (int)1e9, root = 3;
    DecimalFormat df = new DecimalFormat("0.0000000000000");
    double eps = 1e-9;
    FastReader in;
    PrintWriter out;
    static boolean multipleTC = false, memory = false;

    public static void main(String[] args) throws Exception{
        if(memory)new Thread(null, new Runnable() {public void run(){try{new Main().run();}catch(Exception e){e.printStackTrace();}}}, "1", 1 << 28).start();
        else new Main().run();
    }

    void run() throws Exception{
        in = new FastReader();
        out = new PrintWriter(System.out);
        for(int i = 1, t = (multipleTC)?ni():1; i<=t; i++)solve(i);
        out.flush();
        out.close();
    }

    void solve(int TC)throws Exception{
        int n = ni();
        int[] f1 = new int[9], f2 = new int[9];
        MyHashSet<String> set = new MyHashSet<>();
        for(int i = 0; i< n; i++){
            String s = n();
            set.add(s);
            f1[s.length()]++;
        }
        int[] f = new int[4];
        for(int i = 0; i< n; i++){
            String s = n();
            if(set.remove(s))continue;
            else f[s.length()-1]++;
        }
        int ans = 0;
        for(int i = 0; i< 4; i++)ans+=f[i];
        pn(ans);
    }

    class MyHashSet<T>{
        private int size;
        private HashMap<T, Integer> map;
        public MyHashSet(){
            size = 0;
            map = new HashMap<>();
        }
        public int size(){return size;}
        public void add(T t){
            size++;
            map.put(t, map.getOrDefault(t, 0)+1);
        }
        public int cnt(T t){return map.getOrDefault(t,0);}
        public boolean remove(T t){
            if(!map.containsKey(t))return false;
            size--;
            int c = map.get(t);
            if(c==1)map.remove(t);
            else map.put(t, c-1);
            return true;
        }
    }

    int[] reverse(int[] a){
        int[] o = new int[a.length];
        for(int i = 0; i< a.length; i++)o[i] = a[a.length-i-1];
        return o;
    }

    int[] sort(int[] a){
        if(a.length==1)return a;
        int mid = a.length/2;
        int[] b = sort(Arrays.copyOfRange(a,0,mid)), c = sort(Arrays.copyOfRange(a,mid,a.length));
        for(int i = 0, j = 0, k = 0; i< a.length; i++){
            if(j<b.length && k<c.length){
                if(b[j]<c[k])a[i] = b[j++];
                else a[i] = c[k++];
            }else if(j<b.length)a[i] = b[j++];
            else a[i] = c[k++];
        }
        return a;
    }

    long[] sort(long[] a){
        if(a.length==1)return a;
        int mid = a.length/2;
        long[] b = sort(Arrays.copyOfRange(a,0,mid)), c = sort(Arrays.copyOfRange(a,mid,a.length));
        for(int i = 0, j = 0, k = 0; i< a.length; i++){
            if(j<b.length && k<c.length){
                if(b[j]<c[k])a[i] = b[j++];
                else a[i] = c[k++];
            }else if(j<b.length)a[i] = b[j++];
            else a[i] = c[k++];
        }
        return a;
    }

    long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
    int gcd(int a, int b){return (b==0)?a:gcd(b,a%b);}
    int bitcount(long n){return (n==0)?0:(1+bitcount(n&(n-1)));}
    void p(Object o){out.print(o);}
    void pn(Object o){out.println(o);}
    void pni(Object o){out.println(o);out.flush();}
    String n(){return in.next();}
    String nln(){return in.nextLine();}
    int ni(){return Integer.parseInt(in.next());}
    long nl(){return Long.parseLong(in.next());}
    double nd(){return Double.parseDouble(in.next());}

    class FastReader{
        BufferedReader br;
        StringTokenizer st;
        public FastReader(){
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastReader(String s) throws Exception{
            br = new BufferedReader(new FileReader(s));
        }

        String next(){
            while (st == null || !st.hasMoreElements()){
                try{
                    st = new StringTokenizer(br.readLine());
                }catch (IOException  e){
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        String nextLine(){
            String str = "";
            try{
                str = br.readLine();
            }catch (IOException e){
                e.printStackTrace();
            }
            return str;
        }
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Map;
import java.util.HashMap;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author programajor
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            Map<String, Integer> map = new HashMap<>();
            for (int i = 0; i < n; i++) {
                String x = in.next();
                map.put(x, map.getOrDefault(x, 0) + 1);
            }
            int ans = 0;
            for (int i = 0; i < n; i++) {
                String x = in.next();
                if (map.containsKey(x)) {
                    map.put(x, map.get(x) - 1);
                    if (map.get(x) == 0) {
                        map.remove(x);
                    }
                } else {
                    ans++;
                }
            }
            out.print(ans);
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main
{
    static MyScanner scan;
    static PrintWriter pw;
    public static void main(String[] args) {
        new Thread(null,null,"_",1<<25)
        {
            public void run()
            {
                try
                {
                    solve();
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }.start();
    }
    static void solve() throws IOException {
        scan = new MyScanner();
        pw = new PrintWriter(System.out, true);
        StringBuilder sb = new StringBuilder();
        Map<String,Integer> map = new HashMap<>();
        map.put("M",0);
        map.put("L",1);
        map.put("S",2);
        map.put("XL",3);
        map.put("XS",4);
        map.put("XXL",5);
        map.put("XXS",6);
        map.put("XXXL",7);
        map.put("XXXS",8);
        int freqa[] = new int[9];
        int freqb[] = new int[9];
        int n = ni();
        for(int i=0;i<n;++i)
            ++freqa[map.get(ne())];
        for(int i=0;i<n;++i)
            ++freqb[map.get(ne())];
        for(int i=0;i<9;++i)
        {
            int xx = min(freqa[i],freqb[i]);
            freqa[i]-=xx;
            freqb[i]-=xx;
        }
        long res = 0;
        for(int i=0;i<9;++i)
            res+=freqa[i]+freqb[i];
        pl(res/2);
        pw.flush();
        pw.close();
    }
    static long MMI(long A,long MOD)
    {
        return modpow(A,MOD-2,MOD);
    }
    static long modpow(long x,long y,long MOD)
    {
        if(y==0)
            return 1;
        if((y&1)==0)
            return modpow((x*x)%MOD,y>>1,MOD);
        else return (x*modpow(x,y-1,MOD))%MOD;
    }
    static class Pair implements Comparable<Pair>
    {
        int x,y;
        Pair(int x,int y)
        {
            this.x=x;
            this.y=y;
        }
        public int compareTo(Pair other)
        {
            if(this.x!=other.x)
                return this.x-other.x;
            return this.y-other.y;
        }
        public String toString()
        {
            return "{"+x+","+y+"}";
        }
    }
    static int ni() throws IOException
    {
        return scan.nextInt();
    }
    static long nl() throws IOException
    {
        return scan.nextLong();
    }
    static double nd() throws IOException
    {
        return scan.nextDouble();
    }
    static String ne() throws IOException
    {
        return scan.next();
    }
    static String nel() throws IOException
    {
        return scan.nextLine();
    }
    static void pl()
    {
        pw.println();
    }
    static void p(Object o)
    {
        pw.print(o+" ");
    }
    static void pl(Object o)
    {
        pw.println(o);
    }
    static void psb(StringBuilder sb)
    {
        pw.print(sb);
    }
    static class MyScanner
    {
        BufferedReader br;
        StringTokenizer st;
        MyScanner()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String nextLine()throws IOException
        {
            return br.readLine();
        }
        String next() throws IOException
        {
            if(st==null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }
        int nextInt() throws IOException
        {
            return Integer.parseInt(next());
        }
        long nextLong() throws IOException
        {
            return Long.parseLong(next());
        }
        double nextDouble() throws IOException
        {
            return Double.parseDouble(next());
        }
    }
}


import java.util.*;
public class q1
{
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		int[] arr1=new int[9];
		int[] arr2=new int[9];
		String ss;
		s.nextLine();
		for(int i=0;i<n;i++)
		{
			ss=s.nextLine();
			if(ss.equals("M"))
				arr1[0]++;
			else if(ss.equals("S"))
				arr1[1]++;
			else if(ss.equals("L"))
				arr1[2]++;
			else if(ss.equals("XS"))
				arr1[3]++;
			else if(ss.equals("XL"))
				arr1[4]++;
			else if(ss.equals("XXS"))
				arr1[5]++;
			else if(ss.equals("XXL"))
				arr1[6]++;
			else if(ss.equals("XXXS"))
				arr1[7]++;
			else if(ss.equals("XXXL"))
				arr1[8]++;
		}
		for(int i=0;i<n;i++)
		{
			ss=s.nextLine();
			if(ss.equals("M"))
				arr2[0]++;
			else if(ss.equals("S"))
				arr2[1]++;
			else if(ss.equals("L"))
				arr2[2]++;
			else if(ss.equals("XS"))
				arr2[3]++;
			else if(ss.equals("XL"))
				arr2[4]++;
			else if(ss.equals("XXS"))
				arr2[5]++;
			else if(ss.equals("XXL"))
				arr2[6]++;
			else if(ss.equals("XXXS"))
				arr2[7]++;
			else if(ss.equals("XXXL"))
				arr2[8]++;
		}
		int min;
		for(int i=0;i<9;i++)
		{
			if(arr1[i]<arr2[i])
				min=arr1[i];
			else
				min=arr2[i];
			arr1[i]-=min;
			arr2[i]-=min;
		}
		int sum=0;
		for(int i=0;i<9;i++)
		{
			sum+=arr1[i];
		}
		System.out.println(sum);
		//System.out.println(Arrays.toString(arr2));
	}
}


import java.util.*;
import java.io.*;

public class A{

    static int N, M, K;
    static String s;
    static StringTokenizer st;
    static int[] d;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int[][] d = new int[5][3];
        int[][] d2 = new int[5][3];

        int N = Integer.parseInt(br.readLine());
        for (int i = 0; i < N; i++) {
            String r = br.readLine();
            int len = r.length();
            int fin = 0;
            if(r.charAt(r.length()-1) == 'S')
                fin = 0;
            if(r.charAt(r.length()-1) == 'M')
                fin = 1;
            if(r.charAt(r.length()-1) == 'L')
                fin = 2;
            d[len][fin]++;
        }

        for (int i = 0; i < N; i++) {
            String r = br.readLine();
            int len = r.length();
            int fin = 0;
            if(r.charAt(r.length()-1) == 'S')
                fin = 0;
            if(r.charAt(r.length()-1) == 'M')
                fin = 1;
            if(r.charAt(r.length()-1) == 'L')
                fin = 2;
            d2[len][fin]++;
        }

        int ans = 0;
        for (int i = 0; i < d.length; i++) {
            int sum = 0;
            int sum2 = 0;
            for (int j = 0; j < d[0].length; j++) {
                sum += d[i][j];
                sum2 += d2[i][j];
                ans += Math.max(0, d2[i][j] - d[i][j]);
            }

        }
        System.out.println(ans);
        out.close();
    }
}


import java.io.*;
import java.util.*;
public class A {
    public static void main(String[] args)throws Throwable {
        MyScanner sc=new MyScanner();
        PrintWriter pw=new PrintWriter(System.out);

        int n=sc.nextInt();

        String [] s={"M","L","S","XL","XS","XXL","XXS","XXXL","XXXS"};
        int [] cnt=new int [9];
        for(int i=0;i<n;i++){
            String t=sc.next();
            for(int j=0;j<9;j++)
                if(t.equals(s[j]))
                    cnt[j]++;
        }
        for(int i=0;i<n;i++){
            String t=sc.next();
            for(int j=0;j<9;j++)
                if(t.equals(s[j]))
                    cnt[j]--;
        }
        for(int i=0;i<9;i++)
            cnt[i]=Math.abs(cnt[i]);
        int ans=0;
        for(int i=0;i<9;i++)
            ans+=cnt[i];
        pw.println(ans/2);
        pw.flush();
        pw.close();
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;
        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {while (st == null || !st.hasMoreElements()) {
            try {st = new StringTokenizer(br.readLine());}
            catch (IOException e) {e.printStackTrace();}}
            return st.nextToken();}
        int nextInt() {return Integer.parseInt(next());}
        long nextLong() {return Long.parseLong(next());}
        double nextDouble() {return Double.parseDouble(next());}
        String nextLine(){String str = "";
            try {str = br.readLine();}
            catch (IOException e) {e.printStackTrace();}
            return str;}
    }
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

import static java.lang.Math.*;

public class Main implements Runnable {
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }

                if(numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();

            while(isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

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

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            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 String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new Main(),"Main",1<<26).start();
    }

    public void run() {
        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n=sc.nextInt();
        String a[]=new String[n];
        String b[]=new String[n];
        int freaa[][]=new int[5][4];
        for (int i = 0; i <n ; i++) {
            a[i]=sc.next();
            int ll=a[i].length();
            for (int j = 0; j <a[i].length() ; j++) {
                if(a[i].charAt(j)=='X')
                    freaa[ll][0]++;
                if(a[i].charAt(j)=='L')
                    freaa[ll][1]++;
                if(a[i].charAt(j)=='M')
                    freaa[ll][2]++;
                if(a[i].charAt(j)=='S')
                    freaa[ll][3]++;
            }
        }
        int frebb[][]=new int[5][4];
        for (int i = 0; i <n ; i++) {
            b[i]=sc.next();
            int ll=b[i].length();
            for (int j = 0; j <b[i].length() ; j++) {
                if(b[i].charAt(j)=='X')
                    frebb[ll][0]++;
                if(b[i].charAt(j)=='L')
                    frebb[ll][1]++;
                if(b[i].charAt(j)=='M')
                    frebb[ll][2]++;
                if(b[i].charAt(j)=='S')
                    frebb[ll][3]++;
            }
        }
        int ans=0;
        for (int i = 1; i <5 ; i++) {
            for (int j = 0; j <4 ; j++) {
                if(freaa[i][j]<frebb[i][j]){
                    ans+=frebb[i][j]-freaa[i][j];
                }
            }
        }
        out.println(ans);
        out.close();
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class JavaApplication2 {

    public static void main(String[] args) throws IOException {

        BufferedReader sc= new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(sc.readLine().split(" ")[0]);
        ArrayList<String> tshr = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            tshr.add(sc.readLine());
        }
        for (int i = 0; i < n; i++) {
            tshr.remove(sc.readLine());
        }
        System.out.println(tshr.size());

    }

}


import java.util.*;
import java.io.*;

public class _1000_A {

	public static void main(String[] args) throws IOException {
		HashMap<String, Integer> map1 = new HashMap<>(), map2 = new HashMap<>(); int N = readInt();
		for(int i = 1; i<=N; i++) {
			String s = read(); if(!map1.containsKey(s)) map1.put(s, 1); else map1.put(s, map1.get(s)+1);
		}
		int tot = 0; for(int i = 1; i<=N; i++) {
			String s = read(); if(!map2.containsKey(s)) map2.put(s, 1); else map2.put(s, map2.get(s)+1);
		}
		for(String s : map2.keySet()) {
			tot += Math.max(0, map2.get(s) - (map1.containsKey(s) ? map1.get(s) : 0));
		}
		println(tot); exit();
	}

	final private static int BUFFER_SIZE = 1 << 16;
	private static DataInputStream din = new DataInputStream(System.in);
	private static byte[] buffer = new byte[BUFFER_SIZE];
	private static int bufferPointer = 0, bytesRead = 0;
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	public static String readLine() throws IOException {
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = Read()) != -1) {
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public static String read() throws IOException {
		byte[] ret = new byte[1024];
		int idx = 0;
		byte c = Read();
		while (c <= ' ') {
			c = Read();
		}
		do {
			ret[idx++] = c;
			c = Read();
		} while (c != -1 && c != ' ' && c != '\n' && c != '\r');
		return new String(ret, 0, idx);
	}

	public static int readInt() throws IOException {
		int ret = 0;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public static long readLong() throws IOException {
		long ret = 0;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public static double readDouble() throws IOException {
		double ret = 0, div = 1;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();

		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');

		if (c == '.') {
			while ((c = Read()) >= '0' && c <= '9') {
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private static void fillBuffer() throws IOException {
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private static byte Read() throws IOException {
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	static void print(Object o) {
		pr.print(o);
	}

	static void println(Object o) {
		pr.println(o);
	}

	static void flush() {
		pr.flush();
	}

	static void println() {
		pr.println();
	}

	static void exit() throws IOException {
		din.close();
		pr.close();
		System.exit(0);
	}
}


import java.io.*;
import java.util.*;

public class n2{
    public static void main(String[] args) throws Exception{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(in.readLine());
        int[] S=new int[4];
        int[] L=new int[4];
        int m=0;
        for(int i=0;i<n;i++){
            String s=in.readLine();
            if(s.charAt(s.length()-1)=='L'){
                L[s.length()-1]++;
            }
            if(s.charAt(s.length()-1)=='S'){
                S[s.length()-1]++;
            }
            if(s.charAt(s.length()-1)=='M'){
                m++;
            }
        }
        for(int i=0;i<n;i++){
            String s=in.readLine();
            if(s.charAt(s.length()-1)=='L'){
                L[s.length()-1]--;
            }
            if(s.charAt(s.length()-1)=='S'){
                S[s.length()-1]--;
            }
            if(s.charAt(s.length()-1)=='M'){
                m--;
            }
        }
        int count=0;
        for(int i=0;i<=3;i++){
            if(S[i]>0){
                count+=S[i];
            }
            if(L[i]>0){
                count+=L[i];
            }
        }
        if(m>0){
            count+=m;
        }
        System.out.println(count);
    }
}


import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeSet;

public class Main {
    public static StreamTokenizer tokenizer = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    public static int read() throws IOException {
        tokenizer.nextToken();
        return (int) tokenizer.nval;
    }

    public static void main(String[] args) throws IOException {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        ArrayList<String> list1=new ArrayList<String>();
        ArrayList<String> list2=new ArrayList<String>();
        for (int i=0; i<n; i++){
            String s=scanner.next();
            list1.add(s);
        }
        for (int i=0; i<n; i++){
            String s=scanner.next();
            list2.add(s);
        }
        for (int i=0; i<list1.size(); i++){
            for (int j=0; j<list2.size(); j++){
                if (list1.get(i).equals(list2.get(j))){
                    list1.remove(i);
                    list2.remove(j);
                    i--;
                    break;
                }
            }
        }
        System.out.println(list1.size());
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

public class A {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int n = nextInt();
		String[]a = new String[n], b = new String[n];
		Map<String, Integer> map = new HashMap<String, Integer>();
		for (int i = 0; i < n; i++) {
			a[i] = next();
			if (!map.containsKey(a[i]))
				map.put(a[i], 0);
			map.put(a[i], map.get(a[i])+1);
		}
		int  ans = 0;
		for (int i = 0; i < n; i++) {
			b[i] = next();
			if (!map.containsKey(b[i]))
				ans++;
			else {
				map.put(b[i], map.get(b[i])-1);
				if (map.get(b[i])==0)
					map.remove(b[i]);
			}
		}
		System.out.println(ans);
		pw.close();
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}