import java.io.*;
import java.util.*;

public class Main {
	static InputStream is;
	static PrintWriter out;
	static String INPUT = "";
	
	static final long mod = (long) 1e9 + 7;
	static final int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
	static final int[] dx8 = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy8 = { -1, 0, 1, -1, 1, -1, 0, 1 };
	static final int inf = Integer.MAX_VALUE / 3;
	static final long linf = Long.MAX_VALUE / 3;
	static final double dinf = Double.MAX_VALUE / 3;
	
	static void solve()
	{
		char s[] = ns(4);
		Map<Character,Integer> map = new HashMap<>();
		for(int i=0;i<4;i++) {
			map.put(s[i],map.getOrDefault(s[i],0)+1);
		}
		if(map.size()==2) {
			for(int v:map.values()) {
				if(v!=2) {
					out.println("No");
					return;
				}
			}
			out.println("Yes");
			return;
		}
		out.println("No");
	}
		
	//libraries
		static int[] concat(int x, int arr[]) {
			int ret[] = new int[arr.length + 1];
			System.arraycopy(arr, 0, ret, 1, ret.length - 1);
			ret[0] = x;
			return ret;
		}

		static int[] concat(int arr[], int x) {
			int ret[] = new int[arr.length + 1];
			System.arraycopy(arr, 0, ret, 0, ret.length - 1);
			ret[ret.length - 1] = x;
			return ret;
		}

		static long[] concat(long x, long arr[]) {
			long ret[] = new long[arr.length + 1];
			System.arraycopy(arr, 0, ret, 1, ret.length - 1);
			ret[0] = x;
			return ret;
		}

		static long[] concat(long arr[], long x) {
			long ret[] = new long[arr.length + 1];
			System.arraycopy(arr, 0, ret, 0, ret.length - 1);
			ret[ret.length - 1] = x;
			return ret;
		}

		static long max(long x, long y) {
			return Math.max(x, y);
		}

		static long min(long x, long y) {
			return Math.min(x, y);
		}

		static long max(long x, long y, long z) {
			x = Math.max(x, y);
			x = Math.max(x, z);
			return x;
		}

		static long min(long x, long y, long z) {
			x = Math.min(x, y);
			x = Math.min(x, z);
			return x;
		}

		static double max(double x, double y) {
			return Math.max(x, y);
		}

		static double min(double x, double y) {
			return Math.min(x, y);
		}

		static double max(double x, double y, double z) {
			x = Math.max(x, y);
			x = Math.max(x, z);
			return x;
		}

		static double min(double x, double y, double z) {
			x = Math.min(x, y);
			x = Math.min(x, z);
			return x;
		}

		static void rsort(int[] ar) {
			Arrays.sort(ar);
			int len = ar.length;
			for (int i = 0; i < len / 2; i++) {
				int tmp = ar[i];
				ar[i] = ar[len - 1 - i];
				ar[len - 1 - i] = tmp;
			}
		}

		static void rsort(long[] ar) {
			Arrays.sort(ar);
			int len = ar.length;
			for (int i = 0; i < len / 2; i++) {
				long tmp = ar[i];
				ar[i] = ar[len - 1 - i];
				ar[len - 1 - i] = tmp;
			}
		}

		static void rsort(double[] ar) {
			Arrays.sort(ar);
			int len = ar.length;
			for (int i = 0; i < len / 2; i++) {
				double tmp = ar[i];
				ar[i] = ar[len - 1 - i];
				ar[len - 1 - i] = tmp;
			}
		}

		static void fill(int arr[], int x) {
			Arrays.fill(arr, x);
		}

		static void fill(long arr[], long x) {
			Arrays.fill(arr, x);
		}

		static void fill(double arr[], double x) {
			Arrays.fill(arr, x);
		}

		static void fill(int arr[][], int x) {
			for (int i = 0; i < arr.length; i++)
				Arrays.fill(arr[i], x);
		}

		static void fill(long arr[][], long x) {
			for (int i = 0; i < arr.length; i++)
				Arrays.fill(arr[i], x);
		}

		static void fill(double arr[][], double x) {
			for (int i = 0; i < arr.length; i++)
				Arrays.fill(arr[i], x);
		}

		//MOD culc
		static long plus(long x, long y) {
			long res = (x + y) % mod;
			return res < 0 ? res + mod : res;
		}

		static long sub(long x, long y) {
			long res = (x - y) % mod;
			return res < 0 ? res + mod : res;
		}

		static long mul(long x, long y) {
			long res = (x * y) % mod;
			return res < 0 ? res + mod : res;
		}

		static long div(long x, long y) {
			long res = x * pow(y, mod - 2) % mod;
			return res < 0 ? res + mod : res;
		}

		static long pow(long x, long y) {
			if (y < 0)
				return 0;
			if (y == 0)
				return 1;
			if (y % 2 == 1)
				return (x * pow(x, y - 1)) % mod;
			long root = pow(x, y / 2);
			return root * root % mod;
		}
	
		public static void main(String[] args) throws Exception
		{
			is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
			out = new PrintWriter(System.out);
			solve();
			out.flush();
		}
		
	//input
	private static byte[] inbuf = new byte[1024];
	static int lenbuf = 0, ptrbuf = 0;
	
	private static int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}
	
	private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
	
	private static double nd() { return Double.parseDouble(ns()); }
	private static char nc() { return (char)skip(); }
	
	private static String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}
	
	private static char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}
	
	private static char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}
	
	private static int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}
	
	private static int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}
		
		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}
	
	private static long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}
		
		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}
	
}


Measured memory_bytes: 21204