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()

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

print(ans)

Solution (Python):
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math


MOD = 10 ** 9 + 7




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

print(dif)

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

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_s = input()
t_s = input()
ans = 0
for s, t in zip(s_s, t_s):
    if s != t:
        ans += 1
print(ans)

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

print([s == t for s, t in zip(S, T)].count(False))

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()
ans = 0

for s,t in zip(S,T):
    if s != t:
        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()

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

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

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):
s = input()
t = input()
cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt +=1
print(cnt)

Solution (Python):

def main():
  s = input()
  t = input()

  num = 0
  for i in range(len(s)):
    if s[i] is not t[i]:
      num += 1

  print(num)


main()

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

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

print(counter)

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
input = sys.stdin.readline


def main():
    S = input().strip()
    T = input().strip()

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

if __name__ == "__main__":
    print(main())

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

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

Solution (Python):

import sys

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()
cnt = 0
for x in range(len(s)):
    if(s[x] != t[x]):
        cnt+=1
print(cnt)

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

Solution (Python):
def main():
    ss = list(input())
    ts = list(input())
    ans = 0
    for s, t in zip(ss, ts):
        if s != t:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

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):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

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

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):
inpl = lambda: list(map(int,input().split()))
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()
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())

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)):
    if s[i] != t[i]:
        ans += 1
        
print(ans)

Solution (Python):
import itertools
import decimal
import math
from collections import Counter
import sys
input = sys.stdin.readline

S=input()
T=input()

ans=0

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

print(ans)

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

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

print(ams)

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 = input()
t = input()
l = len(s)

print(len([i for i in range(l) if s[i] != t[i]]))

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()
c = 0
for s, t in zip(S,T):
    if s != t:
        c += 1
print(c)

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

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

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

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):
from sys import stdin,stdout
LI=lambda:list(map(int,input().split()))
MAP=lambda:map(int,input().split())
IN=lambda:int(input())
S=lambda:input()
import math
def p(a):print(" ".join(list(map(str,a))))
from collections import Counter

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

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 = list(input())
t = list(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())
n=len(s)
z=0
for i in range (n):
    if s[i]!=t[i]:
        z+=1
print(z)

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

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

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

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

res = 0
for s, t in zip(S, T):
    if s != t:
        res += 1

print(res)

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

ans = 0
for i in range(l):
    if S[i] != T[i]:
        ans = 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):
x = 0;
s = str(input());
t = str(input());
v = len(s);

for i in range(v):
    if s[i] != t[i]:
        x += 1;
print(x);

Solution (Python):
from sys import stdin


def main():
    input = lambda: stdin.readline()[:-1]
    S = input()
    T = input()

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


main()

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

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

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

Solution (Python):
s=input()
t=input()
len_s=len(s)
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())
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)

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

print(ans)

Solution (Python):


import sys
input=sys.stdin.readline

def main():
    S=input().strip("\n")
    T=input().strip("\n")
    cnt=0
    for i in range(len(S)):
        if S[i]==T[i]:
            cnt+=1
    print(len(S)-cnt)
    
    
    
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):
def main():
    s = input()
    t = input()
    res = 0
    for a, b in zip(s, t):
        if a != b:
            res += 1
    print(res)

if __name__ == '__main__':
    main()

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):
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
s = input()
t = input()
n = len(s)
c = 0
for i in range(n):
    if s[i] != t[i]:
        c+=1
print(c)

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):
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):
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") 

s = input()
t = input()

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

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()
ans = 0
for i, v in enumerate(s):
    if v != t[i]:
        ans += 1
print(ans)

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

count = 0
for i in range(len(s)):
    if not 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()

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

print(ops)

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

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

Solution (Python):
S = input()
T = input()
count = 0
for s, t in zip(S,T):
    if s != t:
        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()

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

print(ans)

Solution (Python):
S=input()
T=input()
count=0
N=len(S)
for i in range(N):
    if S[i]!=T[i]:
        count+=1
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():
    s = input()
    t = input()
    r = 0
    for i, se in enumerate(s):
        if se != t[i]:
            r += 1
    print(r)

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()
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())
def Main(S, T):
    ans = 0
    for s, t in zip(S, T):
        if s != t:
            ans += 1
    return ans
    
res = Main(S, T)
print(res)

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)):
    if (s[i] != t[i]):
        ans += 1

print(ans)

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)):
  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):


import sys
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

S = readline().decode().rstrip()
T = readline().decode().rstrip()

cnt = 0
for s, t in zip(S, T):
    if s != t:
        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()
l = len(s)
c = 0
for i in range(l):
    if s[i]!=t[i]:
        c+=1
print(c)

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 sys import stdin
input = stdin.readline
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
ins = lambda : input().strip()
DBG = True 
BIG = 10**18
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

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

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):
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):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    S=input()
    T=input()
    print(sum(s!=t for s, t in zip(S, T)))




main()

Solution (Python):
import sys
input = sys.stdin.readline

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

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

print(ans)

Solution (Python):




def main():
    s = input().strip()
    t = input().strip()

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


if __name__ == '__main__':
    main()

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

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

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

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):
a=input()
b=input()

count=0
for i in range(len(a)):
  if a[i] != b[i]:
    count+=1
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):

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()

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

print(sm)

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

    print(cnt)

   
if __name__ == '__main__':
    main()

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()
c=0
for i in range(len(s)):
    if s[i] != t[i]:
        c+=1
print(c)

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()
c=0
for i in range(len(s)):
    if s[i]!=t[i]:
        c+=1
print(c)

Solution (Python):










import sys

def input(): return sys.stdin.readline()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip("\n") for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst): print(*lst)
def OutV(lst): print(*lst, sep="\n")

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


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):
S = input()
T= input()

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

Solution (Python):
"""
    こんにちは。これはクシャルです
    
    Author : thekushalghosh (クシャル)
    Team   : CodeDiggers
 
    I prefer Python language over the C++ language :p :D
        
    Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()



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


 
def main():
    global tt
    if not ONLINE_JUDGE:
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    t = 1
    for tt in range(t):
        solve()
    if not ONLINE_JUDGE:
        print("Time Elapsed :",time.time() - start_time,"seconds")
        sys.stdout.close()
    

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    return(input().strip())
def invr():
    return(map(int,input().split()))
 

def counter(a):
    q = [0] * max(a)
    for i in range(len(a)):
        q[a[i] - 1] = q[a[i] - 1],1
    return(q)
 
def string_counter(a):
    q = [0] * 26
    for i in range(len(a)):
        q[ord(a[i]) - 97] = q[ord(a[i]) - 97],1
    return(q)

def factors(n):
    q = []
    for i in range(1,int(n ** 0.5) + 1):
        if n % i == 0: q.append(i); q.append(n // i)
    return(list(sorted(list(set(q)))))

def prime_factors(n):
    q = []
    while n % 2 == 0: q.append(2); n = n // 2
    for i in range(3,int(n ** 0.5) + 1,2):
        while n % i == 0: q.append(i); n = n // i
    if n > 2: q.append(n)
    return(list(sorted(q)))


        
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
    input = sys.stdin.readline
main()

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

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 c1,c2 in zip(S,T):
    if c1 != c2:
        ans += 1
print(ans)

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

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

Solution (Python):
S = input()
T = input()
cnt = 0
for s, t in zip(S, T):
    if s != t:
        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()
cnt =0
for i in range(len(S)):
    if S[i] == T[i]:
        pass
    else:
        cnt += 1
print(cnt)

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

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())
ans=0
for i in range(len(S)):
    if S[i] != T[i]:
        ans+=1
print(ans)

Solution (Python):
S1 = input()
S2 = input()

N = len(S1)
count = 0
for i in range(N):
    if S1[i] != S2[i]:
        count += 1
print(count)

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

count = 0
for s, t in zip(S, T):
    if s != t:
        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())
counter = 0
for i in range(len(S)):
    if S[i] != T[i]:
        counter += 1
print(counter)

Solution (Python):
s = input()
t = input()
ans = 0
for i in range(len(s)):
    if s[i]==t[i]:
        ans+=1
print(len(s)-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):
from sys import stdin
s = stdin.readline()
t = stdin.readline()
cou = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        cou += 1
print(cou)

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):
def main():
    s = input()
    t = input()

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

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()
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()))
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()

cnt = 0
for s, t in zip(S, T):
    if s != t:
        cnt += 1
    

print(cnt)

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):
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()
N = len(S)
ans = 0
for i in range(N):
    if S[i]!=T[i]:
        ans+=1
print(ans)

Solution (Python):
from sys import stdin, stdout
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from functools import reduce
import math
from bisect import bisect,bisect_right,bisect_left

def get_int():
    return int(stdin.readline().strip())


def get_tuple():
    return map(int, stdin.readline().split())


def get_list():
    return list(map(int, stdin.readline().split()))

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(input())
t = list(input())

c = 0
for S,T in zip(s,t):
    if S != T:
        c += 1

print(c)

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

total = 0
for s, t in zip(S,T):
  if s != t: total += 1
    
print(total)

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())
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 s, t in zip(S, T):
    ans += 1 if s!=t else 0
print(ans)

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):
s=list(input())
t=list(input())
print(sum([x!=y for x,y in zip(s,t)]))

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

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

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

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


if __name__ == '__main__':
    main()

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=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 = 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()
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()

cnt = 0
for i, j in zip(S, T):
    if i != j:
        cnt += 1
print(cnt)

Solution (Python):
from sys import stdin
s = stdin.readline().rstrip()
t = stdin.readline().rstrip()
answer = 0
for i in range(len(s)):
    if s[i] != t[i]:
        answer += 1
print(answer)

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):


from pprint import pprint
from collections import deque, defaultdict
import itertools
import math
import sys

sys.setrecursionlimit(10 ** 6)
INF = float('inf')


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

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

print(res)

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, T = input(), input()
print(sum(s!=t for s, t in zip(S, T)))

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

Solution (Python):
def INT():
    return int(input())

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

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

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):
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()
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 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()
l=0
for i in range(len(s)):
  if s[i]!=t[i]:
    l+=1
print(l)

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()

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

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

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

print(answer)

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 = 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):
import sys
from collections import deque
import copy
def main():
    S = input()
    T = input()
    ans = 0
    for i in range(len(S)):
        if S[i] != T[i]:
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()

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

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

print(ans)

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)):
    if s[i] != t[i]:
        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):
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)):
    if s[i] != t[i]:
        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)