Problem:
 Score : 200 points    Problem Statement Given are strings S and T . Consider changing S to T by repeating the operation below. Find the minimum number of operations required to do so.  Operation: Choose one character of S and replace it with a different character.      Constraints  S and T have lengths between 1 and 2\times 10^5 (inclusive).  S and T consists of lowercase English letters.  S and T have equal lengths.         Input Input is given from Standard Input in the following format:  S  T       Output Print the answer.        Sample Input 1 cupofcoffee
cupofhottea      Sample Output 1 4  We can achieve the objective in four operations, such as the following:   First, replace the sixth character c with h .  Second, replace the eighth character f with t .  Third, replace the ninth character f with t .  Fourth, replace the eleventh character e with a .        Sample Input 2 abcde
bcdea      Sample Output 2 5       Sample Input 3 apple
apple      Sample Output 3 0  No operations may be needed to achieve the objective.

Solution (Python):
s=input()
t=input()
count=0
for i in range(len(s)):
    if s[i]==t[i]:
        continue
    else:
        count+=1
        
        
print(count)

Solution (Python):
s=input()
t=input()
count=0
for i in range(len(s)):
    if s[i]==t[i]:
        continue
    else:
        count+=1
        
        
print(count)

Solution (Python):
n=input()
nn=input()
c=0
for i in range(len(n)):
    if(n[i]!=nn[i]):
        c+=1
print(c)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    s=input()
    t=input()
    cnt=0
    for i in range(len(s)):
        if s[i]!=t[i]:
            cnt+=1
    print(cnt)
resolve()

Solution (Python):
def resolve():
    s=input()
    t=input()
    cnt=0
    for x,y in zip(s,t):
        if x!=y:
            cnt+=1
    print(cnt)
resolve()

Solution (Python):
s = input()
t = input()
ans=0
for i in range(len(s)):
  if s[i]!=t[i]:
    ans+=1
    
print(ans)

Solution (Python):
S = input()
T = input()
ans = 0
for i in range(len(S)):
    ans += (S[i] != T[i])
print(ans)

Solution (Python):
StrS = str(input())
StrT = str(input())
counter = 0

for x in range(len(StrS)):
	if StrS[x] == StrT[x]:
		counter = counter + 1
        
print(len(StrS)-counter)

Solution (Python):
S=input()
T=input()
d=int(len(S))
count = 0

for i in range(1,d+1):
    if S[i-1]!=T[i-1]:
        count = count+1
print(count)

Solution (Python):
s,t=map(str,open(0).read().split());l=len(s)
ans=0
for i in range(l):
  if s[i]!=t[i]:
    ans+=1
print(ans)

Solution (Python):
s = input()
t = input()
n = len(s)

ans = 0
for i in range(n):
    if s[i]!=t[i]:
        ans+=1

print(ans)

Solution (Python):
a=input()
b=input()
c=len(a)
d=0
for i in range(c):
  if a[i]==b[i]:
    d=d+1
print(c-d)

Solution (Python):
a = input()
b = input()

if a == b:
  print(0)
  exit(0)

ans = 0
for i in range(len(a)):
  if a[i] != b[i]:
    ans += 1
    
print(ans)

Solution (Python):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right
from math import gcd,ceil,floor,factorial

from functools import reduce
from pprint import pprint
from statistics import mean,median,mode

INF = float("inf")

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

def I():
    return int(input())

def MI():
    return map(int,input().split())

def RI():
    return list(map(int,input().split()))

def CI(n):
    return [ int(input()) for _ in range(n) ]

def LI(n):
    return [ list(map(int,input().split())) for _ in range(n) ]

def S():
    return input()

def MS():
    return input().split()

def RS():
    return list(input().split())

def CS(n):
    return [ input() for _ in range(n) ]

def LS(n):
    return [ list(input().split()) for _ in range(n) ]







s = S()
t = S()

c = 0
for i in range(len(s)):
    if s[i]==t[i]:
        pass
    else:
        c += 1
print(c)

Solution (Python):
S = list(input())
T = list(input())
a = 0
for i in range(len(S)):
    if S[i] != T[i]:
        a += 1
print(a)

Solution (Python):
S, T= input(), input()
N = int(len(S))
x = 0
for i in range(N):
    if S[i] != T[i]:
        x += 1
print(x)

Solution (Python):
s=str(input())
s1=str(input())
c=0
for i in range(0,len(s)):
    if(s[i]!=s1[i]):
        c=c+1
print(c)

Solution (Python):
def main():
    S = str(input())
    T = str(input())
    a = int(0)
    for x in range(len(S)):
      if S[x]!=T[x]:
          a = a + 1
    print(int(a))
main()

Solution (Python):
S = input()
T = input()

i = 0
counts = 0
for i in range(len(S)):
    if(S[i] != T[i]):
        counts += 1

print(counts)

Solution (Python):
s = input()
t = input()
sa = list(s)
ta = list(t)
n=0
for i in range(len(sa)):
    if sa[i]!=ta[i]:
        n=n+1
print(n)

Solution (Python):
S = input()
T = input()
L = len(S)

cnt = 0

for i in range(L):
  if S[i] == T[i]:
    pass
  else:
    cnt += 1
print(cnt)

Solution (Python):
S = input()
T = input()

C = 0

for i in range(len(S)):
  if S[i] == T[i]:
    C+=1
  else:
    pass
  
i+=1

print(len(S) - C)

Solution (Python):
s=input();t=input();
cnt=len(s)
for i in range(len(s)):
  if s[i]==t[i]:
    cnt-=1
    
    
print(cnt)

Solution (Python):
S = input()
T = input()
n = len(S)

c = 0

for p in range(0,n):
    if (S[p] != T[p]):
        c = c + 1 

print(c)

Solution (Python):


s = input()
t = input()

count = 0
length = len(s)

for i in range(length):
    if s[i] != t[i]:
        count += 1

print(count)

Solution (Python):
S = input()
T = input()
num = 0

for i in range(len(T)):
  if (S[i] != T[i]):
   num += 1

print(num)

Solution (Python):
s = input()
t = input()

count = 0
len = len(s)
for i in range(len):
    if s[i] != t[i]:
        count += 1

print(count)

Solution (Python):
S=input()
T=input()
ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):
s = input()
t = input()

i = 0

for s1, s2 in zip(list(s), list(t)):
  if s1 != s2:
    i += 1
    
print(i)

Solution (Python):
s=input()
t=input()
l=len(s)
ans=0

for i in range(l):
  if s[i]!=t[i]:
    ans+=1
    
print(ans)

Solution (Python):
s = input()
t = input()
sum = 0

for i in range(0, len(s)):
  if s[i] != t[i] :
    sum += 1
  
print(sum)

Solution (Python):
S = input()
T = input()
cnt = 0
for i in range(len(S)):
  if S[i] != T[i]:
    cnt += 1
print(cnt)

Solution (Python):
s = input()
t = input()

cnt= 0
for i in range(len(s)):
    if s[i]!=t[i]:
        cnt+=1
print(cnt)

Solution (Python):
s = input()
t = input()
a = 0

for n in range(len(s)):
  a += 1 if s[n] != t[n] else 0

print(a)

Solution (Python):
s1 = input()
s2 = input()
t = 0

for i in range(len(s1)):
  t += 1 if s1[i] != s2[i] else 0
  
print(t)

Solution (Python):
a=list(input())
b=list(input())
s=0
for i in range (0,len(a)):
  if a[i] != b[i]:
    s=s+1
print(s)

Solution (Python):
a = input()
b = input()

diff =0

for i in range(len(a)):
    if a[i] != b[i]:
        diff = diff+1

print(diff)

Solution (Python):
s = input().strip()
t = input().strip()
ans = 0
for i, _ in enumerate(s):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
S = input()
T = input()
count = 0
for i in range(len(S)):
  if S[i] != T[i]:
    count += 1
print(count)

Solution (Python):
S = input()
T = input()
ans=0
for i in range(len(S)):
    if S[i] != T[i]:
        ans+=1
print(ans)

Solution (Python):
s=input()
t=input()
a=0
for i in range(len(s)):
    if s[i]!=t[i]:
        a += 1
print(a)

Solution (Python):
S = input()
T = input()
print(sum([s!=t for s, t in zip(S,T)]))

Solution (Python):
s=input()
t=input()
c=0
for i in range(len(s)):
  if s[i]!=t[i]: c+=1
print(c)

Solution (Python):
def solve(s, t):
    return len(list(filter(lambda x: x[0]!=x[1], zip(s, t))))

s = input()
t = input()
print(solve(s, t))

Solution (Python):
s = str(input())
t = str(input())
 
count = 0
for i in range(len(s)):
  if s[i] != t[i]:
    count +=1 
    
print(count)

Solution (Python):
S=input()
T=input()
count=0
for i in range(len(S)):
  if S[i]!=T[i]:
    count +=1
print(count)

Solution (Python):
s = input()
t = input()
cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1
print(cnt)

Solution (Python):
s=input()
t=input()
l=len(s)
count=0
for x in range(l):
  if s[x]==t[x]:
    count+=1
ans=l-count
print(ans)

Solution (Python):
S = input()
T = input()

ans = sum([S[i] != T[i] for i in range(len(S))])
print(ans)

Solution (Python):
import collections as cc
import itertools as it
I=lambda:list(map(int,input().split()))
a=input()
b=input()
ans=0
for i in range(len(a)):
	if a[i]!=b[i]:
		ans+=1
print(ans)

Solution (Python):
s = input()
t = input()
x = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        x += 1
print(x)

Solution (Python):
S = str(input())
T = str(input())
l = len(S)
count = 0
for i in range(l):
    if S[i] != T[i]:
        count += 1
print(count)

Solution (Python):
s, t, c = input(), input(), 0
for i in range(len(s)):
  if s[i] != t[i]: c += 1
print(c)

Solution (Python):
s = input()
t = input()
c = 0
for i in range(len(s)):
  if s[i] != t[i]:
    c += 1
print(c)

Solution (Python):
s = list(str(input()))
t = list(str(input()))

count = 0

for i in range(len(s)):
  if s[i] != t[i]:
    count += 1
    
print(count)

Solution (Python):
s = list(str(input()))
t = list(str(input()))

count = 0

for i in range(len(s)):
  if s[i] != t[i]:
    count += 1
    
print(count)

Solution (Python):
s = list(input())
t = list(input())
n = len(s)

u = 0
for i in range(n):
    if s[i] != t[i]:
        u += 1
print(u)

Solution (Python):
input1 = input()
input2 = input()

def match(x, y):
    i = 0
    if x is y:
        i = 1
    return i

result_list = list(map(match, input1, input2))
print(result_list.count(0))

Solution (Python):
S=list(input())
T=list(input())
ANS=0
for i in range(len(S)):
    if not S[i]==T[i]:
        ANS+=1
print(ANS)

Solution (Python):
s = input()
t = input()
count = 0
for i in range(len(t)):
  if s[i] != t[i]:
    count += 1
    
    
print(count)

Solution (Python):
S=input()
T=input()
print(sum([S[i]!=T[i] for i in range(len(S))]))

Solution (Python):

s = input()
t = input()
tot = 0
for i in range(len(s)):
    tot += 1 if s[i]!=t[i] else 0
print(tot)

Solution (Python):
s = input()
r = input()
cnt = 0
for i in range(len(s)):
    if s[i] != r[i]:
        cnt += 1

print(cnt)

Solution (Python):
s = input()
t = input()
ans = 0
for i in range(len(s)):
  if s[i] != t[i]:
    ans += 1
print(ans)

Solution (Python):
S = input()
T = input()

S = list(S)
T = list(T)

i = 0
j = 0

while j < len(S):
    if S[j] == T[j]:
        i = i
        j += 1
    else:
        i += 1
        j += 1

print(i)

Solution (Python):
S = input()
T = input()
W = 0
for i in range(len(S)):
    if S[i] != T[i]:
        W += 1
print(W)

Solution (Python):
s = input()
t = input()
a = 0
for i in range(len(s)):
  if not s[i] == t[i]:
    a += 1
    
print(a)

Solution (Python):
import re
import sys
S = input()
T = input()
w = 0
if not re.match(r'^[a-z]+$', S) or not re.match(r'^[a-z]+$', T) or len(S) != len(T) or (10 ** 5 * 2) < len(S):
  sys.exit()
if S != T:
  i = 0
  for l in S:
    if l != T[i]:
      w = w + 1
    i = i + 1
print(w)

Solution (Python):
s = input()
t = input()
count = 0
for i in range(len(s)):
    if s[i] != t[i]:
        count+=1
print(count)

Solution (Python):
firstString = input()
secondString = input()
diff = 0
for i in range(len(firstString)):
    if firstString[i] != secondString[i]:
        diff += 1
print(diff)

Solution (Python):

a = list(input())
b = list(input())
ans = 0
for _ in range(len(a)):
    x = a.pop()
    y = b.pop()
    if x != y:
        ans += 1
print(ans)

Solution (Python):
s = input()
t = input()
count = 0
for i in range(len(s)):
    if s[i] != t[i]:
        count += 1
print(count)

Solution (Python):
s = input()
t = input()

op = 0

for i in range(len(s)):
    if s[i] != t[i]:
        op += 1

print(op)

Solution (Python):
s=input()
t=input()
num=0
for i in range(len(s)):
    if s[i]!=t[i]:
        num=num+1
print(num)

Solution (Python):
s1 = input()
s2=input()
ans = 0
for i in range(len(s1)):
  if s1[i] != s2[i]:
    ans+=1
    
print(ans)

Solution (Python):
import sys

if sys.subversion[0] == "PyPy":
    import io, atexit

    sys.stdout = io.BytesIO()
    atexit.register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

    sys.stdin = io.BytesIO(sys.stdin.read())
    input = lambda: sys.stdin.readline().rstrip()
RS = raw_input
RA = lambda x=int: map(x, RS().split())
RN = lambda x=int: x(RS())


def solve():
    ans = 0
    for i in range(len(s)):
        if s[i] !=t[i]:
            ans += 1
    print(ans)

    return





s = RS()
t = RS()
solve()

Solution (Python):
S = input()
T = input()
ans = 0
for s, t in zip(S, T):
    if s != t:
        ans += 1
print(ans)

Solution (Python):


s = list(str(input()))
t = list(str(input()))

ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):




s=list(input())
t=list(input())
count=0
for si, vi in zip(s,t):
    if si!=vi:
        count+=1
print(count)

Solution (Python):
s = input()
t = input()

x = 0
for (i, j) in zip(s, t):
    if i != j:
        x += 1
print(x)

Solution (Python):
s = input()
t = input()
a = 0
for i,j in zip(s,t):
	if i != j:
  		a+=1
print(a)

Solution (Python):
s=input()
t=input()
cnt=0
for i in range(len(s)):
  if s[i]!=t[i]:
    cnt+=1
print(cnt)

Solution (Python):
S = input()
T = input()
ppap = 0
NHK = 0
for i  in range(len(S)):
  if not S[i] == T[i]:
    ppap += 1
print(ppap)

Solution (Python):
S=list(str(input()))
T=list(str(input()))

count=0
for i in range(len(S)):
    if S[i] != T[i]:
        S[i] = T[i]
        count += 1
        
print(count)

Solution (Python):
S = input()
T = input()
check = 0
for i in range(len(S)):
    if S[i] != T[i]:
        check += 1

print(check)

Solution (Python):
s = input()
t = input()
answer = 0
for ws, wt in zip(s, t):
    if ws != wt:
        answer += 1
print(answer)

Solution (Python):
s = input()
t = input()
n = len(s)
ans = 0
for i in range(n):
  if s[i] != t[i]:
    ans += 1
print(ans)

Solution (Python):
s = input()
t = input()

count=0
for idx, i in enumerate(s):
  if s[idx]!=t[idx]:
    count+=1
print(count)

Solution (Python):
S=input()
T=input()
k=0
for i in range(len(S)):
  if S[i]!=T[i]:
    k+=1
print(k)

Solution (Python):

import sys
input = sys.stdin.readline



def swaparr(arr, a,b):
    temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp


def gcd(a,b):
    if b == 0:
        return a
    return gcd(b, a % b);


def nCr(n, k): 
    if(k > n - k): 
        k = n - k 
    res = 1
    for i in range(k): 
        res = res * (n - i) 
        res = res / (i + 1) 
    return int(res) 


def upper_bound(a, x, lo=0):
    hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if a[mid] < x:
            lo = mid+1
        else:
            hi = mid
    return lo


def primefs(n):
    
    primes = {}
    while(n%2 == 0 and n > 0):
        primes[2] = primes.get(2, 0) + 1
        n = n//2
    for i in range(3, int(n**0.5)+2, 2):
        while(n%i == 0 and n > 0):
            primes[i] = primes.get(i, 0) + 1
            n = n//i
    if n > 2:
        primes[n] = primes.get(n, 0) + 1
    
    
    return primes


def power(x, y, p): 
    res = 1
    x = x % p  
    if (x == 0) : 
        return 0
    while (y > 0) : 
        if ((y & 1) == 1) : 
            res = (res * x) % p 
        y = y >> 1      
        x = (x * x) % p 
    return res 


def swap(a,b):
    temp = a
    a = b
    b = temp
    return a,b









def find(x, link):
    p = x;
    while( p != link[p]):
        p = link[p];
    
    while( x != p):
        nex = link[x];
        link[x] = p;
        x = nex;
    return p;




def union(x, y, link, size):
    x = find(x, link)
    y = find(y, link)
    if size[x] < size[y]:
        x,y = swap(x,y)
    if x != y:
        size[x] += size[y]
        link[y] = x


def sieve(n): 
    prime = [True for i in range(n+1)] 
    p = 2
    while (p * p <= n): 
        if (prime[p] == True): 
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    return prime


MAXN = int(1e7 + 5)
def spf_sieve():
    spf[1] = 1;
    for i in range(2, MAXN):
        spf[i] = i;
    for i in range(4, MAXN, 2):
        spf[i] = 2;
    for i in range(3, ceil(MAXN ** 0.5), 2):
        if spf[i] == i:
            for j in range(i*i, MAXN, i):
                if spf[j] == j:
                    spf[j] = i;
    




def factoriazation(x):
    ret = {};
    while x != 1:
        ret[spf[x]] = ret.get(spf[x], 0) + 1;
        x = x//spf[x]
    return ret
    
    


def int_array():
    return list(map(int, input().strip().split()))

def str_array():
    return input().strip().split();


MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');



a = input().strip(); b = input().strip();
ans = 0;
for i in range(len(a)):
    if a[i] != b[i]:
        ans += 1;
print(ans);

Solution (Python):
s=input()
t=input()
n=len(s)
ans=0
for i in range(n):
    if s[i]!=t[i]:
        ans+=1
print(ans)

Solution (Python):
S = input()
T = input()

num = 0
for ind, s in enumerate(S):
    if  S[ind] != T[ind]:
        num = num + 1
print(num)

Solution (Python):
s = input()
t = input()
kasan = 0
for i in range(len(s)):
    if s[i] == t[i]:
        pass
    else:
        kasan += 1
print(kasan)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")


def solve():
    s = S()
    t = S()
    ans = 0
    for i, si in enumerate(s):
        ans += si != t[i]
    print(ans)
    return



if __name__ == '__main__':
    solve()

Solution (Python):

s=list(map(str,input()))
t=list(map(str,input()))
a=len(s)
cnt=0
for i in range(a):
  if s[i]==t[i]:
    pass
  else:
    cnt+=1
print(cnt)

Solution (Python):
s=input()
t=input()
count=0 
for i in range(0,len(s)):
    if(s[i]!=t[i]):
        count+=1 
print(count)

Solution (Python):
s=input()
t=input()

cnt=0
for i in range(len(s)):
  if s[i] != t[i]:
    cnt += 1
    
print(cnt)

Solution (Python):
import sys
import math
import collections
import heapq
import queue
import itertools
import functools
import operator
import time

readline = sys.stdin.readline
 
IPS = lambda: readline().rstrip()
IP = lambda: int(readline().rstrip())
MP = lambda: map(int, readline().split())
LS = lambda: list(map(int, readline().split()))

def solve():
    for _ in range(1):
        s = IPS()
        t = IPS()
        cnt = 0
        for i in range(len(s)):
            if s[i]!=t[i]: cnt+=1
        
        print(cnt)
       
if __name__ == "__main__":
    solve()

Solution (Python):
S=input()
T=input()
N=len(S)
ans=0
for i in range(N):
  if S[i]!=T[i]:
    ans+=1
    
print(ans)

Solution (Python):
S = input()
T = input()
change = 0
for i in range(len(S)):
  if S[i] != T[i]:
    change += 1
print(change)

Solution (Python):
s=input()
t=input()
x=len(s)
ans=0
for i in range(x):
  if s[i]!=t[i]:
    ans+=1
print(ans)

Solution (Python):
import sys

s = list(input())
t = list(input())

if s == t: print(0), sys.exit()

"""
cnt = 0
for i in range(len(s)):
    if t[i] != s[i]:
        
        cnt += 1
print(cnt)
"""


res = len([1 for i, j in zip(s, t) if i != j])
print(res)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
s = list(input())
t = list(input())

if s == t: print(0), sys.exit()

cnt = 0
for i in range(len(s)):
    if t[i] != s[i]:
        t[i] = s[i]
        cnt += 1
print(cnt)

Solution (Python):

S = list(input())
T = list(input())


res = len([1 for s, t in zip(S, T) if s != t])
print(res)

Solution (Python):
s=str(input())
t=str(input())
length=len(s)
count=0
for i in range(length):
	if s[i]==t[i]:
		pass
	else:
		count+=1
print(count)

Solution (Python):
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
s=str(input())
t=str(input())
length=len(s)
count=0
for i in range(length):
	if s[i]==t[i]:
		pass
	else:
		count+=1
print(count)

Solution (Python):
s, t, c = input(), input(), 0
for i in range(len(s)): c += 1 if s[i] != t[i] else 0
print(c)

Solution (Python):
s1 = input()
s2 = input()
n = len(s1)
ans = sum([1 for i in range(n) if s1[i] != s2[i]])
print(ans)

Solution (Python):
ans = 0
for i, j in zip(input(), input()):
  if i != j:
    ans += 1
print(ans)

Solution (Python):
s = input()
t = input()
n = len(s)
ans = 0

for i in range(n):
    if s[i] != t[i]:
        ans += 1
        
print(ans)

Solution (Python):
S = list(input())
T = list(input())
count = 0
for i in range(len(S)):
    if S[i] != T[i]:
        count += 1
print(count)

Solution (Python):
S = str(input())
T = str(input())
n = 0

for i in range(len(S)):
  if S[i] != T[i]:
    n += 1
    
print(n)

Solution (Python):
s=input()
t=input()
ans=0
for i in range(len(s)):
    if s[i]!=t[i]:
        ans+=1
        
print(ans)

Solution (Python):
from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
    return int(input())

def rl():
    return list(map(int, input().split()))


def solve():
    s = input()
    t = input()
    ans = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            ans += 1
    print (ans)






mode = 's'

if mode == 'T':
    t = ri()
    for i in range(t):
        solve()
else:
    solve()

Solution (Python):
s = input()
t = input()

ans = 0
for x,y in zip(s,t):
    if x != y:
        ans += 1
        
print(ans)

Solution (Python):
s = input()
t = input()

cnt = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        cnt+=1
print(cnt)

Solution (Python):
origin = input()
target = input()
res = 0

for x, y in zip(origin, target):
  if x != y:
    res += 1
print(res)

Solution (Python):
s = str(input())
t = str(input())
count = 0

for i in range(len(s)):
    if s[i] != t[i]:
        count +=1

print(count)

Solution (Python):
S = list(input ())
T = list(input ())
a = len(S)
change_time = 0
 
for i in range(a):
  if S[i] ==T[i]:
  	continue
  
  else:
 
  	change_time += 1
  
  
print(change_time)

Solution (Python):
s=input()
t=input()
o=0
for i in range(len(s)):
  if s[i]!=t[i]:
    o+=1
print(o)

Solution (Python):
def main():
    S = input()
    T = input()
    ans = 0
    for s, t in zip(S, T):
        if s != t:
            ans += 1
    print(ans)
    return


main()

Solution (Python):
a = list(input())
b = list(input())
x = 0
for i in range(len(a)):
  if a[i] == b[i]:
    continue
  else:
    x += 1

print(x)

Solution (Python):
s = list(input())
t = list(input())
count = 0
for i in range(len(s)):
    if s[i] != t[i]:
        count += 1

print(count)

Solution (Python):
s=list(input())
t=list(input())
l=len(s)
c=[1 if s[i]!=t[i] else 0 for i in range(len(s))]
print(sum(c))

Solution (Python):
s = input()
t = input()
n = len(s)
ans = 0
for i in range(n):
    if s[i] != t[i]:
        ans += 1
print(ans)

Solution (Python):
S, T = input(), input()
ans = 0
for i in range(len(S)):
    if S[i] != T[i]:
        ans += 1
print(ans)

Solution (Python):
S = input()
T = input()
lis_s=[]
lis_t=[]

for i in S:
    lis_s.append(i)

for j in T:
    lis_t.append(j)

counter=0
for k in range(len(S)):
    if lis_s[k]==lis_t[k]:
        counter+=1
print(len(S)-counter)

Solution (Python):
a1 = input()
a2 = input()
t = 0

for i in range(len(a1)):
  if a1[i] != a2[i]:
    t += 1
    
print(t)

Solution (Python):
def main():
    s=input()
    t=input()
    print(sum(a!=b for a,b in zip(s,t)))
main()

Solution (Python):
a=input()
b=input()
c=0
for i in range(len(a)):
  if a[i]!=b[i]:
    c=c+1
    
print(c)

Solution (Python):
s=list(input())
t=list(input())
ans = 0
for i, _s in enumerate(s):
    if s[i] != t[i]:
        ans+=1
print(ans)

Solution (Python):
s=input()
t=input()
s=list(s)
t=list(t)
ans=0
for i in range(len(s)):
  if s[i] != t[i]:
    ans+=1
print(ans)

Solution (Python):
S = input()
T = input()
lst = [1 for i, j in zip(S, T) if i != j]
print(sum(lst))

Solution (Python):
s=input()
t=input()
cnt=0
for i in range(len(s)):
  if s[i]!=t[i]:
    cnt+=1
print(cnt)

Solution (Python):
s = input()
t = input()
n = len(s)

cnt = 0
for i in range(n):
    if s[i] != t[i]:
        cnt += 1

print(cnt)

Solution (Python):
s=input()
t=input()
print(sum(1 for x,y in zip(s,t) if x!=y))

Solution (Python):
count = 0

for s, t in zip(input(), input()):
    count += s != t

print(count)

Solution (Python):
s=list(input())
t=list(input())
ans=0
for i in range(len(s)):
    if s[i]!=t[i]:
        ans+=1
print(ans)

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline

    s = input()
    t = input()
    ans = 0

    for si, ti in zip(s, t):
        if si != ti:
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
s = input()
t = input()

sum = 0
for i in range(len(s)):
    if s[i] != t[i]:
        sum += 1
print(sum)

Solution (Python):
S=input()
T=input()
print(sum([1 if x[0]!=x[1] else 0 for x in zip(S,T)]))

Solution (Python):
s=input()
t=input()

ans = 0

for i in range(len(s)):
	if s[i]!=t[i]:
		ans+=1

print(ans)

Solution (Python):
S = list(input())
T = list(input())
y = 0
for x in range(len(S)):
  if not S[x] == T[x]:
    y += 1

print(y)

Solution (Python):
S = input()
T = input()

cnt = 0
for i in range(len(S)):
    if(S[i] != T[i]):
        cnt += 1
print(cnt)

Solution (Python):
s = input()
t = input() 
ans = 0
for i in range(len(s)):
    if(s[i] != t[i]):
        ans += 1
print(ans)

Solution (Python):
"""
// Author : snape_here - Susanta Mukherjee
     
 """
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
 
def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 

def isPrime(n):
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
    return True

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

mod=1000000007

from math import *

import bisect

from decimal import *

getcontext().prec = 50

abc="abcdefghijklmnopqrstuvwxyz"

pi=3.141592653589793238

def main():

    s=si()
    t=si()
    c=0 
    for i in range(len(s)):
        if s[i]!=t[i]:
            c+=1 
    print(c)



 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

Solution (Python):
s=input()
t=input()
ans=0
for i in range(len(s)):
    if s[i] != t[i]:
        ans+=1
print(ans)

Solution (Python):
S = input()
T = input()
ls = list(S)
ln = len(ls)
ans = 0
for i in range(ln):
   if S[i] != T[i]:
     ans += 1
print(ans)

Solution (Python):


import copy
import random
import bisect 
import fractions 
import math
import sys
import collections
from decimal import Decimal 

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

S = str(input())
T = str(input())

cnt = 0
for i in range(len(S)):
    if S[i] != T[i]:
        cnt += 1

print(cnt)

Solution (Python):
s,t=input(),input()
slen=len(s)

j=0
count=0
for i in range(slen):
    if s[j]!=t[j]:
        count+=1
    j+=1    
    
print(count)

Solution (Python):
s=input()
t=input()
ans=0
for i in range(len(s)):
    if s[i]==t[i]:
        continue
    ans+=1
print(ans)

Solution (Python):
print(sum(a!=b for a,b in zip(input(),input())))