You are given two strings a and b consisting of lowercase English letters, both of length n. The characters of both strings have indices from 1 to n, inclusive. 

You are allowed to do the following changes: 

  * Choose any index i (1 ≤ i ≤ n) and swap characters a_i and b_i; 
  * Choose any index i (1 ≤ i ≤ n) and swap characters a_i and a_{n - i + 1}; 
  * Choose any index i (1 ≤ i ≤ n) and swap characters b_i and b_{n - i + 1}. 



Note that if n is odd, you are formally allowed to swap a_{⌈n/2⌉} with a_{⌈n/2⌉} (and the same with the string b) but this move is useless. Also you can swap two equal characters but this operation is useless as well.

You have to make these strings equal by applying any number of changes described above, in any order. But it is obvious that it may be impossible to make two strings equal by these swaps.

In one preprocess move you can replace a character in a with another character. In other words, in a single preprocess move you can choose any index i (1 ≤ i ≤ n), any character c and set a_i := c.

Your task is to find the minimum number of preprocess moves to apply in such a way that after them you can make strings a and b equal by applying some number of changes described in the list above.

Note that the number of changes you make after the preprocess moves does not matter. Also note that you cannot apply preprocess moves to the string b or make any preprocess moves after the first change is made.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 10^5) — the length of strings a and b.

The second line contains the string a consisting of exactly n lowercase English letters.

The third line contains the string b consisting of exactly n lowercase English letters.

Output

Print a single integer — the minimum number of preprocess moves to apply before changes, so that it is possible to make the string a equal to string b with a sequence of changes from the list above.

Examples

Input

7
abacaba
bacabaa


Output

4


Input

5
zcabd
dbacz


Output

0

Note

In the first example preprocess moves are as follows: a_1 := 'b', a_3 := 'c', a_4 := 'a' and a_5:='b'. Afterwards, a = "bbcabba". Then we can obtain equal strings by the following sequence of changes: swap(a_2, b_2) and swap(a_2, a_6). There is no way to use fewer than 4 preprocess moves before a sequence of changes to make string equal, so the answer in this example is 4.

In the second example no preprocess moves are required. We can use the following sequence of changes to make a and b equal: swap(b_1, b_5), swap(a_2, a_4).
import java.util.*;
import java.io.*;

public class Main {
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long mod = 1000000000 + 7;
	private static long mod1 = 1000000000 + 9;
	private static int MAX=1000001;
	private static int block;
	private static LinkedList<Integer> list[];
	private static boolean Visited[];
	private static int Array[];
	private static int tree[];
	private static int count[];
	private static int result[];
	private static ArrayList<Integer> color[];
	
	private static void soln(){
	
		int n,count=0,flag1=0,flag2=0;
		n=nextInt();
		String s1,s2;
		s1=nextLine();
		s2 = nextLine();
		int x=0,y=n-1;
		while(y>=x)
		{
			flag1=0;
			flag2=0;
			if(y==x)
			{
				if(s1.charAt(x)==s2.charAt(x));
				else
					count++;
				y=y-1;
				x=x+1;
			}
			else
			{
				if(s2.charAt(x)== s2.charAt(y))
				{
					flag1=1;
				}
				else
					flag2=1;
				
				if(flag1==1)
				{
					if(s1.charAt(x)==s1.charAt(y));
					else
						count++;
				}
				else
				{
					if(s1.charAt(x)==s1.charAt(y))
					{
					if(s1.charAt(x)==s2.charAt(x)||s1.charAt(x)==s2.charAt(y))
					{
						count++;
					}
					else
					{
						count = count+2;
					}
					}
					else
					{
						if(s1.charAt(x)==s2.charAt(x)||s1.charAt(x)==s2.charAt(y))
						{
							if(s1.charAt(y)==s2.charAt(x)||s1.charAt(y)==s2.charAt(y));
							else
								count++;
						}
						else
						{
							if(s1.charAt(y)==s2.charAt(x)||s1.charAt(y)==s2.charAt(y))
								count++;
							else
								count=count+2;
						}
					}
				}
				x=x+1;
				y=y-1;
			}
		}
		System.out.println(count);
	}
	
	
	
	public static void build(int node, int start, int end,int[] A,int[] B)
	{
	    if(start == end)
	    {
	        // Leaf node will have a single element
	    	if(A[start]+B[start]==2)
	        tree[node] = 1;
	    	else
	    		tree[node] = 0;
	    	if(A[start]+B[start]==0)
	    		Visited[node]=true;
	    	else
	    		Visited[node]=false;
	    }
	    else
	    {
	        int mid = (start + end) / 2;
	        // Recurse on the left child
	        build(2*node, start, mid,A,B);
	        // Recurse on the right child
	        build(2*node+1, mid+1, end,A,B);
	        // Internal node will have the sum of both of its children
	        if(Visited[2*node] || Visited[2*node+1])
	        	Visited[node]=true;
	        if(tree[2*node+1]==1 || ( tree[2*node]==1 && Visited[2*node+1]==false ))
	        	tree[node]=1;
	        else
	        	tree[node]=0;
	    }
	}
	
	public static void update(int node, int start, int end, int idx, int[] A,int[] B)
	{
	    if(start == end)
	    {
	        // Leaf node
	    	if(A[start]+B[start]==2)
		        tree[node] = 1;
		    	else
		    		tree[node] = 0;
		    	if(A[start]+B[start]==0)
		    		Visited[node]=true;
		    	else
		    		Visited[node]=false;
	    }
	    else
	    {
	        int mid = (start + end) / 2;
	        if(start <= idx && idx <= mid)
	        {
	            // If idx is in the left child, recurse on the left child
	            update(2*node, start, mid, idx, A, B);
	        }
	        else
	        {
	            // if idx is in the right child, recurse on the right child
	            update(2*node+1, mid+1, end, idx, A, B);
	        }
	        // Internal node will have the sum of both of its children
	        if(Visited[2*node] || Visited[2*node+1])
	        	Visited[node]=true;
	        if(tree[2*node+1]==1 || ( tree[2*node]==1 && Visited[2*node+1]==false ))
	        	tree[node]=1;
	        else
	        	tree[node]=0;
	    }
	}
	
	public static int query(int node, int start, int end, int l, int r)
	{
	    if(r < start || end < l)
	    {
	        // range represented by a node is completely outside the given range
	        return 2;
	    }
	    if(l <= start && end <= r)
	    {
	        // range represented by a node is completely inside the given range
	        return tree[node];
	    }
	    // range represented by a node is partially inside and partially outside the given range
	    int mid = (start + end) / 2;
	    int p1 = query(2*node, start, mid, l, r);
	    int p2 = query(2*node+1, mid+1, end, l, r);
	    if(p2!=2)
	    {
	    	if(p1+p2>=2)
	    	return 1;
	    	else
	    		return 0;
	    }
	    else
	    {
	    	if(p1==1)
	    		return 2;
	    	else
	    	{
	    		if(Visited[2*node]==false)
	    		return 1;
	    		else
	    			return 0;
	    	}
	    }
	}
	
	public static int dfs(int x,int k)
	{
		int sum=0;
		int size=0;
		Visited[x]=true;
		color[Array[x]].add(x);
		size=color[Array[x]].size();
		if(color[Array[x]].size()>k)
		{
			result[x]=color[Array[x]].get(size-k-1);
		}
		else
		{
			result[x]=-1;
		}
		
		for(Integer a:list[x])
		{
			if(!Visited[a])
			{
				dfs(a,k);
			}
		}
		color[Array[x]].remove(size-1);	
		return 0;
	}

	public static int bfs(int s,int d)
	{
		 //int count[] = new int[101];
		 //count[100]=-1;
		 //boolean Visited[] = new boolean[101];
		
		int c = 0;
		LinkedList<Integer> queue = new LinkedList<Integer>();
		
		Visited[s]=true;
		queue.add(s);
		
		
		while(queue.size()!=0)
		{
			
			s=queue.poll();
			c = count[s]+1;
			for(Integer x: list[s])
			{
				if(Visited[x]!=true)
				{
					Visited[x]=true;
					queue.add(x);
					count[x]=c;
				}
				if(x==d)
					return 0;
			}
		}
		
		return 0;
		
	}
	
	
	
	
	
	
	
	public static class disjointunion
	{
		int parent[],rank[],number[];
		int n;
	public	disjointunion(int n){
			rank = new int[n];
			parent = new int[n];
			number = new int[n];
			this.n=n;
			makeset();
		}
  void makeset()
  {	
	  for(int i=0;i<n;i++)
	  {
		parent[i]=i;
		number[i]=1;
	  }
  }
	int find(int i)
	{
		if(parent[i]!=i)
		{
			parent[i]=find(parent[i]);
		}
			return parent[i];
	}
	void union(int x,int y)
	{
		int xRoot , yRoot;
		xRoot = find(x);
		yRoot = find(y);
		if(xRoot==yRoot)
		return;
		
		if(rank[xRoot]<rank[yRoot])
		{
			parent[xRoot]=yRoot;
			number[yRoot] += number[xRoot];
			number[xRoot]=0;
		}
		if(rank[xRoot]>rank[yRoot])
		{
			parent[yRoot]=xRoot;
			number[xRoot] += number[yRoot];
			number[yRoot]=0;
		}
		if(rank[xRoot]==rank[yRoot])
		{
			parent[xRoot]=yRoot;
			number[yRoot] += number[xRoot];
			number[xRoot]=0;
			rank[yRoot]++;
		}
	}
	}	
		
	public static void main(String[] args) throws Exception 
	{
		new Thread(null,new Runnable()
		{
			@Override
			public void run() 
			{
				InputReader(System.in);
				pw = new PrintWriter(System.out);
				soln();
				pw.close();
			}
		},"1",1<<26).start();
	}

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

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

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

	private static 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 static 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 static 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 static 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 static 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 static int[] nextIntArray(int n) 
	{
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) 
		{
			arr[i] = nextInt();
		}
		return arr;
	}

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

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

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

	private static boolean isSpaceChar(int c) 
	{
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}
	private static 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);
	}
	
	
}