Rudolf is on his way to the castle. Before getting into the castle, the security staff asked him a question:

Given two binary numbers a and b of length n. How many different ways of swapping two digits in a (only in a, not b) so that bitwise OR of these two numbers will be changed? In other words, let c be the bitwise OR of a and b, you need to find the number of ways of swapping two bits in a so that bitwise OR will not be equal to c.

Note that binary numbers can contain leading zeros so that length of each number is exactly n.

[Bitwise OR](https://en.wikipedia.org/wiki/Bitwise_operation#OR) is a binary operation. A result is a binary number which contains a one in each digit if there is a one in at least one of the two numbers. For example, 01010_2 OR 10011_2 = 11011_2.

Well, to your surprise, you are not Rudolf, and you don't need to help him… You are the security staff! Please find the number of ways of swapping two bits in a so that bitwise OR will be changed.

Input

The first line contains one integer n (2≤ n≤ 10^5) — the number of bits in each number.

The second line contains a binary number a of length n.

The third line contains a binary number b of length n.

Output

Print the number of ways to swap two bits in a so that bitwise OR will be changed.

Examples

Input

5
01011
11001


Output

4


Input

6
011000
010011


Output

6

Note

In the first sample, you can swap bits that have indexes (1, 4), (2, 3), (3, 4), and (3, 5).

In the second example, you can swap bits that have indexes (1, 2), (1, 3), (2, 4), (3, 4), (3, 5), and (3, 6).
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
 
import static java.lang.Math.*;
 
public class bits 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 bits(),"bits",1<<26).start();
    }
    /*class Wand {
        int ind;
        int val;
        Wand(int a, int b) {
            ind = a;
            val = b;
        }
    }*/ //(This statement shows how to make our own class)
    
    //to count no of 1 in binary form::
    long count_one (int n){
            long count=0;
            while(n>0)
            {
               n = n&(n-1);
               count++;
            }
            return count;
       }
    //To Find most significant setbit of a number::
    int Last_set_bit(int n){
        return (int)(Math.log(n)/Math.log(2));
    }   
    //power mod::
    static long powmod(long x, long n, long m) {
        if (n == 0) return 1;

        else if (n % 2 == 0) return powmod(((x % m) * (x % m)) % m, n / 2, m);

        else if (n % 2 == 1) return (((x % m) * powmod(((x % m) * (x % m)) % m, (n - 1) / 2, m)) % m);

        else return 0;
    }
    //binary expo::
    static long binaryexpo(long x, long n){
        if(n==0) return 1;
        if(n%2==0) return binaryexpo(x*x,n);
        else return x*binaryexpo(x*x,(n-1)%2);
    }
    //GCD od 2 nos::
    public static long gcd(long a, long b) {
        if(b==0) return a;
        return gcd(b%a,a);
    }
    //GCD of Array::
    public static long gcd(long[] input) {
        long result = input[0];
 
        for (int i = 1; i < input.length; i++) {
            result = gcd(result, input[i]);
        }
 
        return result;
    }
    //LCM of 2 nos::
    public static long lcm(long a, long b) {
        return a * (b / gcd(a, b));
    }
    //LCM of Array::
    public static long lcm(long[] input) {
        long result = input[0];
 
        for (int i = 1; i < input.length; i++) {
            result = lcm(result, input[i]);
        }
 
        return result;
    }
    //BINARY TREE::
    public class Node{
        int data;
        Node left,right;
        Node(int data){
            this.data = data;
            left = right = null;
        }

        public void insert(int value){
            if(value<=data){
                if(left==null) left = new Node(value);
                else left.insert(value);
            }
            else{
                if(right==null) right = new Node(value);
                else right.insert(value);
            }
        }  

        public boolean contains(int value){
           if(value==data) return true;
            else if(value<data){
                if(left==null) return false;
                else return left.contains(value);
            }
            else{
                if(right==null) return false;
                else return right.contains(value);
            }
        }
    }
    //FOR FINDING HEIGHT OF A TREE::
    public int maxht(Node root){
        if(root == null) return 0;
        else{
            int ld = maxht(root.left);
            int rd = maxht(root.right);
            
            if(ld>rd) return ld+1;
            else return rd+1;
        }
    }
    //Graph::
    public class graph{
        ArrayList<Integer> a;
        int d;
        boolean b;

        void graph(){
            this.d = 0;
            this.b = false;
        }
    }
    //Code starts right here... 
    public void run()
    {
        InputReader sc = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        /*write your code here*/
        /*take input through sc.nextInt and all and output through w.print & w.println*/
        int n = sc.nextInt();
        char s1[] = sc.next().toCharArray();
        char s2[] = sc.next().toCharArray();
        long count=0;
        ArrayList<Integer> al = new ArrayList<>();
        int l = s1.length;
        int a1[] = new int[2];
        int t[] = new int[2]; 
        for(int c=0;c<l;c++){
            if(s2[c]=='0'){
                al.add(c);
                if(s1[c]=='0') a1[0]++;
                else a1[1]++;
            }
            if(s1[c]=='0') t[0]++;
            else t[1]++;
        }
        for(int c=0;c<al.size();c++){
            if(s1[al.get(c)]=='0') count+=((long)Math.abs(a1[1]-t[1])+a1[1]);
            else count+=(long)Math.abs(a1[0]-t[0]);   
        }
        w.println(count);
        w.close();
    }
    
}