Petya loves lucky numbers very much. Everybody knows that lucky numbers are positive integers whose decimal record contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.

Petya has two strings a and b of the same length n. The strings consist only of lucky digits. Petya can perform operations of two types: 

  * replace any one digit from string a by its opposite (i.e., replace 4 by 7 and 7 by 4); 
  * swap any pair of digits in string a. 



Petya is interested in the minimum number of operations that are needed to make string a equal to string b. Help him with the task.

Input

The first and the second line contains strings a and b, correspondingly. Strings a and b have equal lengths and contain only lucky digits. The strings are not empty, their length does not exceed 105.

Output

Print on the single line the single number — the minimum number of operations needed to convert string a into string b.

Examples

Input

47
74


Output

1


Input

774
744


Output

1


Input

777
444


Output

3

Note

In the first sample it is enough simply to swap the first and the second digit.

In the second sample we should replace the second digit with its opposite.

In the third number we should replace all three digits with their opposites.
import java.io.*;
import java.util.*;
import java.math.*;
import java.awt.image.AreaAveragingScaleFilter;
import static java.lang.Math.*;
import java.lang.*;



public class Main{
    static FastScanner in;
    static PrintWriter out;
    final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    public static void main(String[] args) throws FileNotFoundException {
        Locale.setDefault(Locale.US);

        if (ONLINE_JUDGE){
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
        }else{
            in = new FastScanner(new File("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        }

        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }


}

class SegmentTree{
    int t[], lazy[];
    int Size;
    public SegmentTree(int size){
        t = new int[size*4];
        lazy = new int[size*4];
        Size = size;
    }

    public void build(int e[], int v, int tl, int tr){
        if (tl==tr) t[v] = e[tl]; else
        {
            int m = (tl+tr) >> 1;
            build(e, v+v, tl, m);
            build(e, v+v+1, m+1, tr);
            t[v] = t[v+v]+t[v+v+1];
        }
    }

    public int get(int v, int tl, int tr, int l, int r){
        push(v, tl, tr);
        if (tl==l && tr==r) return t[v];
        int m = (tl+tr) >> 1;
        push(v+v, tl, m);
        push(v+v+1, m+1, tr);
        if (r<=m) return get(v+v, tl, m, l, r);
        if (l>m) return get(v+v+1, m+1, tr, l, r);
        int a = get(v+v,tl, m, l, m);
        int b = get(v+v+1, m+1, tr, m+1, r);
        return a+b;
    }

    public void push(int v, int tl, int tr){
        if (lazy[v]==1) {
            if (tl != tr) {
                lazy[v + v] ^= 1;
                        lazy[v + v + 1] ^= 1;
            }
            t[v] = (tr - tl + 1) - t[v];
            lazy[v] = 0;
        }
    }

    public void update(int v, int tl, int tr, int l, int r){

        push(v, tl, tr);
        if (tl==l && tr==r) {
            lazy[v]=1;
            push(v, tl, tr);
            return;
        }
        int mid = (tl+tr) >> 1;
        push(v+v, tl, mid);
        push(v+v+1, mid+1, tr);
        if (r<=mid) update(v+v, tl, mid, l, r); else
        if (l>mid) update(v+v+1, mid+1, tr, l, r); else
        {
            update(v+v, tl, mid, l, mid);
            update(v+v+1, mid+1, tr, mid+1, r);
        }

        t[v] = t[v + v] + t[v+v+1];
    }

    public int Get(int l, int r){
        return get(1, 1, Size, l, r);
    }

    public void Update(int l, int r){
        update(1, 1, Size, l, r);
    }

}


class Task {
    final int N = 100100;
    final int Inf = 1000000007;
    int n, x, k;
    Map<Integer, Integer> mp;
    long f[] = new long[N];

    long binpow(long a, long b, long c){
        long r=1;
        while (b>0){
            if ((b&1)>0) r*=a;
            a*=a;
            r%=c;
            a%=c;
            b>>=1;
        }
        return r;
    }

    long inverse(long a, long b, long c){
        return binpow(a, b-2, c);
    }


    boolean lucky(int x){
        boolean ans = true;
        while (x>0){
            int dig = (x % 10);
            if (dig!=4 && dig!=7) ans = false;
            x/=10;
        }
        return ans;
    }

    void inc(Map<Integer, Integer> mp, int pos, int val){
        if (mp.containsKey(pos)) val+=mp.get(pos);
        mp.remove(pos);
        mp.put(pos, val);
    }

    long C(int n, int k){
        if (n<k) return 0;
        if (n==k) return 1;
        /*long p=1;
        for (int i=1; i<=n; i++) p*=i;
        for (int i=1; i<=k; i++) p/=i;
        for (int i=1; i<=n-k; i++)p/=i;*/
        long p=f[n];
        p*=inverse(f[k], Inf, Inf);
        p%=Inf;
        p*=inverse(f[n-k], Inf, Inf);
        p%=Inf;
        return p;
    }

    public void solve(int testNumber, FastScanner in, PrintWriter out) {
        String s1 = in.next();
        String s2 = in.next();
        int a=0, b=0;
        for (int i=0; i<s1.length(); i++){
            char aa = s1.charAt(i);
            char bb = s2.charAt(i);
            if (aa=='4' && bb=='7') a++; else
                if (aa=='7' && bb=='4') b++;
        }
        out.println(max(a, b));
    }

}

class Pair implements Comparable<Pair>{
    public int first, second;
    Pair(){
        first=second=-1;
    }
    Pair(int a, int b){
        first = a; second=b;
    }
    @Override
    public int compareTo(Pair b){
        if (first<b.first) return 1; else
        if (first>b.first) return -1; else
        if (second<b.second)  return 1; else return -1;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        char c = (char)42;
        result = (int)(1L*first*second + first + second);
        if (second!=0) result+=first % second;
        if (first!=0) result+=second%first;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        Pair b = (Pair)obj;
        if (first==b.first && second==b.second) return true;
        return false;
    }

}

class PairComparator implements Comparator<Pair>{

    public int compare(Pair a, Pair b) {
        if (a.first<b.first) return 1; else
        if (a.first>b.first) return -1; else
        if (a.second<b.second)  return 1; else return -1;
    }
}


class FastScanner {
    BufferedReader br;
    StringTokenizer st;

    public FastScanner(File f) {
        try {
            br = new BufferedReader(new FileReader(f));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

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

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

    boolean hasMoreTokens() {
        while (st == null || !st.hasMoreTokens()) {
            String s = null;
            try {
                s = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (s == null)
                return false;
            st = new StringTokenizer(s);
        }
        return true;
    }

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

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

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