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

print(count)

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

count = 0

for index, c in enumerate(S):
    if T[index] != c:
        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):
from sys import stdin
data = stdin.readlines()

a = data[0].split()[0]
b = data[1].split()[0]

counter = 0
for i in range(0,len(a)):
    if not a[i] == b[i]:
        counter += 1
print(counter)

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

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

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()
i=0
count=0
if s==t:
  print(count)
else:
  while i<len(s):
    if s[i]!=t[i]:
      count+=1
    i+=1
  print(count)

Solution (Python):

from collections import deque
from collections import Counter
from operator import itemgetter
from bisect import bisect_left, bisect
from decimal import *
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)


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

Solution (Python):
s=input()
t=input()
c = 0
for i in range(len(s)):
    if s[i]==t[i]:
        c+=1
print(len(s)-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):
a = input()
b = input()
l = 0
for i in range(len(a)):
   if not (a[i] == b[i]):
      l+=1
print(l)

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

print(ans)

Solution (Python):
from sys import stdin

def main():
    s = input()
    t = input()
    cnt = 0
    for a,b in zip(s,t):
        if not a == b:
            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()
ans = 0
for (i, j) in zip(s, t):
    if i != j:
        ans += 1
print(ans)

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

count=0

for i in range(0,len(s)):
    if s[int(i)]!=t[int(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 heapq as hq
def inp():
	return (int(input()))


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


def insr():
	s=input()
	return (list(s[:len(s)]))


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


def subset_sum_count(arr,n,sum):
	dp=[[0 for _ in range(sum+1)] for _ in range(n+1)]
	for i in range(n+1):
		for j in range(sum+1):
			if j==0:
				dp[i][j]=1
			elif arr[i-1]<=j:
				dp[i][j]=dp[i-1][j-arr[i-1]]+dp[i-1][j]
			else:
				dp[i][j]=dp[i-1][j]
	return dp[n][sum]


def prefix(a):
	pre=[]
	pre.append(a[0])
	for i in range(1,len(a)):
		pre.append(pre[i-1]+a[i])
	return pre

def str_to_integer_list(n):
	a=[]
	for i in range(len(n)):
		a.append(int(n[i]))
	return a
def list_to_str(l):
	s=""
	for i in l:
		s+=str(i)
	return s
def binarySearch(arr,low,high,x):
	if (high>=low):
		mid=low+(high-low)//2
		if x==arr[mid]:
			return (mid)
		elif (x>arr[mid]):
			return binarySearch(arr,(mid+1),high,x)
		else:
			return binarySearch(arr,low,(mid-1),x)
	
	return -1


def right_shift(a,s):
	return a[s:]+a[:s]


def dijkstra(s,N,E):
	visited=set()
	dist={}
	for i in range(1,N+1):
		dist[i]=1<<29
	queue=[(dist[i],i) for i in range(1,N+1)]
	hq.heappush(queue,(0,s))
	dist[s]=0
	while queue:
		d,u=hq.heappop(queue)
		if u in visited:
			continue
		
		for t in E[u]:
			v,r=t
			if dist[v]>d+r:
				dist[v]=d+r
				hq.heappush(queue,(dist[v],v))
		
		visited.add(u)
	return dist


def path(start,end,parent):
	path=[end]
	while path[-1]!=start:
		path.append(parent[path[-1]])
	path.reverse()
	return path


def bfs(graph,start,end):
	parent={}
	queue=[]
	queue.append(start)
	while queue:
		node=queue.pop(0)
		if node==end:
			return path(start,end,parent)
		for next in graph.get(node,[]):
			if node not in queue:
				parent[next]=node
				queue.append(next)


'''for _ in range(int(input())):
	n,m=list(map(int,input().split()))
	graph=[[]for _ in range(n+1)]
	distance=[-1]*(n+1)
	visited=[False]*(n+1)
	for _ in range(m):
		x,y=list(map(int,input().split()))
		graph[x].append(y)
		graph[y].append(x)'''
'''T = int(input())
for i in range(0, T):
	N, M = map(int, input().split(' '))
	graph = {}
	for j in range(1, N+1):
		graph[j] = []
	for j in range(0, M):
		x, y, r = map(int, input().split(' '))
		graph[x].append((y,r))
		graph[y].append((x,r))'''
s=insr()
t=insr()
c=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(input())
T = list(input())

print(sum(map(lambda x: x[0] != x[1], zip(S, T))))

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

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

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

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

c = 0
for i,v in enumerate(S):
    if v != T[i]:
        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 = list(input())
T = list(input())
ctr = 0
for i in range (len(S)):
  if S[i] != T[i]:
    ctr += 1
print(ctr)

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

length = len(S)
count = 0

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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


s = readline().decode().rstrip()
t = readline().decode().rstrip()

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

Solution (Python):
s=input()
t=input()
i=0
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):
inputStr1 = input()
inputStr2 = input()
count = 0

for s1, s2 in zip(inputStr1, inputStr2):
    if s1 != s2:
        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 = list(input())
T = list(input())
cnt = 0

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

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

print(sum)

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

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

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

num = 0

l = len(T)

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

print(num)

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

Solution (Python):
from queue import LifoQueue


def print_sol(c, sol):
    print('Case 


def rd_int():
    return int(input())


def rd_str():
    return input()


def rd_str_lst():
    return input().split(' ')


def sp_str_lst():
    return list(input())


def rd_int_lst():
    return [int(i) for i in rd_str_lst()]


def sp_int_lst():
    return [int(i) for i in sp_str_lst()]


def dfs(g, i, v):
    """
    recursive post order dfs
    Args:
        g: array of graph nodes
        i: node to traverse
        v: visited array

    Returns: a post order dfs of graph g
    """
    v[i] = True
    for j in g[i]:
        if not v[j]:
            dfs(g, j, v)

    print(i)


def dfs_iter(g, i, n):
    v = [False] * n
    stack = LifoQueue()
    stack.put(i)
    while stack.not_empty:
        u = stack.get()
        v[u] = True
        print(u)
        for i in g[u]:
            if not v[i]:
                stack.put(i)


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

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

    print(sol)


if __name__ == '__main__':
    main()

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

result = [x for x in map(set, zip(S, T)) if len(x) == 2]
print(len(result))

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

if __name__ == "__main__":
    resolve()

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

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

print(num)

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 = input()
T = input()
count = 0

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

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

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

print(result)

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

Solution (Python):
one = input()
two = input()
cnt = 0

for o, t in zip(one, two):
  if o != t:
    cnt += 1

print(cnt)

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

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

res = 0

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

print(res)

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

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

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

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

ans = 0

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

print(ans)

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

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

Solution (Python):


import sys
import math


debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        
        
        lines.append(input())
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    s = lines[0]
    t = lines[1]

    return (s, t)


def solve(s, t):
    
    result = 0
    for c, d in zip(s, t):    
        if c != d:
            result += 1
                
    return result    


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, sep='')
    else:
        print("%s" % result, sep='')

if __name__ == '__main__':

    main()

Solution (Python):
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):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


def ceil(a, b): return (a + b - 1) // b


inf = float('inf')
mod = 10 ** 9 + 7


def pprint(*A):
    for a in A:     print(*a, sep='\n')


def INT_(n): return int(n) - 1


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


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [I() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


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


def F(): return float(input())


def ST(): return input().replace('\n', '')

def main():
    S = input()
    T = input()
    ans = 0
    if S == T:
        print(0)
        sys.exit()
    for i in range(len(S)-1):
        if S[i] != T[i]:
            ans+=1
    print(ans)

if __name__ == '__main__':
    main()

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

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

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

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

print(cnt)

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

num=len(s)
ans=num

for i in range(num):
    if s[i]==t[i]:
        ans-=1

print(ans)

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

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

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

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

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

print(count)

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

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

count=0
for i in range(len(s)):
  if s[i] != t[i]:
    count=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()
sl = len(s)
cnt = 0
for i in range(sl):
  if s[i] == t[i]:
    pass
  else:
    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 = ans + 1

print(ans)

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

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

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

Solution (Python):
INT_MAX=10**30+7
MOD=10**9+7
def INPUT():return list(int(i) for i in input().split())
def LIST_1D_ARRAY(n):return [0 for _ in range(n)]
def LIST_2D_ARRAY(m,n):return [[0 for _ in range(n)]for _ in range(m)]

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

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

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

    print(c)
    
if __name__=='__main__':
    main()

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

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

S=list(input().rstrip('\n'))
T=list(input().rstrip('\n'))
print(len([i for i in range(len(S)) if S[i]!=T[i]]))

Solution (Python):

right=list(input())
left=list(input())

count=0

for i in range(len(right)):
    if right[i]!=left[i]:
        count=count + 1
    else:
        continue

print(count)

Solution (Python):
s1 = input()
s2 = input()
cnt = 0
for i in range(len(s1)):
  if(s1[i] != s2[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()

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

print(count)

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

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

print(count)

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

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

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

Solution (Python):
s=input()
t=input()
n=len(s)-1
count=0
while n>=0:
    if s[n]!=t[n]:
        count+=1
    n-=1
print(count)

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

str_len = len(s)

ans = 0

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

print(ans)

Solution (Python):
def main():
    import sys
    def input(): return sys.stdin.readline().rstrip()
    S = input()
    T = input()
    count = 0
    for s,t in zip(S,T):
        if s != t:
            count += 1
    print(count)


if __name__ == '__main__':
    main()

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

Solution (Python):
S = list(input())
T = list(input())
count = 0
for i in range(len(S)):
    if(S[i] != T[i]):
        T[i] = S[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()

count = 0
for idx, s in enumerate(S):
    count += 1 if s != T[idx] else 0
print(count)

Solution (Python):
def _main(s, t):
    if s == t:
        print(0)
        return
    change = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            change += 1
    print(change)


if __name__ == "__main__":
    S = str(input())
    T = str(input())
    _main(S, T)

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

Solution (Python):
from sys import exit





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

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

Solution (Python):
"""everything has a cost!"""

from math import *
import random, functools, collections, sys

__author__ = 'p7x'







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

Solution (Python):

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

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

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

Solution (Python):
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
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()
s_l = list(s)
t_l = list(t)
ans=0

for i in  range(len(s_l)):
    if not s_l[i]==t_l[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):
def main():
    s = input()
    t = input()

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

    print(ans)
main()

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

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

print(counter)

Solution (Python):
S = input()
T = input()
N = len(S)
ans = 0

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

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

print(ans)

Solution (Python):
s,t=input(),input()
r=0
for c,d in zip(s,t):
	r+=c!=d
print(r)

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

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

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

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

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

L= len(S)

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

Solution (Python):

def resolve():
    S = input()
    T = input()
    ans = 0
    for s, t in zip(S, T):
        if s != t:
            ans += 1
    print(ans)
    
if __name__ == "__main__":
    resolve()

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

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

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

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

print(res)

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):
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
count = 0
s = str(input())
t = str(input())
for i in range(len(s)):
    if not s[i]== t[i]:
        count +=1

print(count)

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

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

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

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

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

print(len(S) - tmp)

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

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()
count = 0
for i,j in zip(s,t):
  if i != j:
    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):
import numpy as np

S = np.array(list(input()))
T = np.array(list(input()))

print(np.count_nonzero(S != T))

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

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

print(count)

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

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

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

Solution (Python):

s=input()
t=input()





cnt = 0
i = 0
while i <= (len(s)-1):
    if s[i] != t[i]:
        cnt += 1
    i += 1
print(cnt)

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

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

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):
import sys
import math


from sys import stdin,stdout
from collections import deque,defaultdict
from math import ceil,floor,inf,sqrt,factorial,gcd,log2
from copy import deepcopy
ii1=lambda:int(stdin.readline().strip())
is1=lambda:stdin.readline().strip()
iia=lambda:list(map(int,stdin.readline().strip().split()))
isa=lambda:stdin.readline().strip().split()
mod=1000000007
s=is1()
ss=is1()
n=len(s)
count=0
for i in range(n):
    if s[i]!=ss[i]:
        count+=1
print(count)

Solution (Python):
s = input()
t = input()
res = 0
for i in range(len(s)):
    if s[i]!=t[i]:
        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):
def main(s, t):
    r = 0
    for i in range(len(s)):
        if s[i] != t[i]:
            r += 1
    return r

if __name__ == "__main__":
    s = input()
    t = input()
    print(main(s, t))

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

leng = len(s)
count = 0

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

print(count)

Solution (Python):
S = input()
T = input()
count = 0
for i, s in enumerate(S):
    if s == T[i]:
        continue
    count += 1
print(count)

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

Solution (Python):



s = input()
t = input()

r = 0

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

print(r)

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