Let's call a string adorable if its letters can be realigned in such a way that they form two consequent groups of equal symbols (note that different groups must contain different symbols). For example, ababa is adorable (you can transform it to aaabb, where the first three letters form a group of *a*-s and others — a group of *b*-s), but cccc is not since in each possible consequent partition letters in these two groups coincide.

You're given a string *s*. Check whether it can be split into two non-empty subsequences such that the strings formed by these subsequences are adorable. Here a subsequence is an arbitrary set of indexes of the string.
The only line contains *s* (1 ≤ |*s*| ≤ 10<sup class="upper-index">5</sup>) consisting of lowercase latin letters.
In sample case two zzcxx can be split into subsequences zc and zxx each of which is adorable.

There's no suitable partition in sample case three.
ababa
Yes
zzcxx
Yes
yeee
No
a
No
bbab
No
abcd
Yes
abc
No
abcdaaaa
Yes
aaaaaaaaaaaaaaa
No
adb
No
dcccbad
Yes
bcbccccccca
Yes
abcdefgh
No
aabcdef
No
aabc
Yes
ssab
Yes
ccdd
Yes
abcc
Yes
ab
No
abcde
No
aa
No
aaabbb
Yes
bbbba
No
abbbc
Yes
baabaa
Yes
abacabadde
No
aabbcc
Yes
abbc
Yes
aaaaaaabbbbbbcder
No
aabb
Yes
aabbccddee
No
abca
Yes
aaabbbccc
Yes
import re
import math
import decimal
import bisect

def read():
	return input().strip()

# code goes here
can = False
word = read()
if len(word) < 4:
	# print("if len(word) < 4:")
	can = False
else:
	chars = {}
	for c in word:
		if c not in chars:
			chars[c] = 1
		else:
			chars[c] += 1

	vals = sorted(chars.values())
	if len(chars) > 4 or len(chars) == 1:
		# print("if len(chars) > 4 or len(chars) == 1:")
		can = False
	elif len(chars) == 2:
		# print("elif len(chars) == 2:")
		can = vals[0] > 1 and vals[1] > 1
		# print("vals[0] > 1 and vals[1] > 1 is", can)
	else:
		# print("else:")
		can = True
		# print("vals[0] >= 2 and vals[1] >= 2 and vals[2] == 1 is", can)

print("Yes" if can else "No")
