Problem: You are given three integers a, b, k.

Find two binary integers x and y (x ≥ y) such that 

  1. both x and y consist of a zeroes and b ones; 
  2. x - y (also written in binary form) has exactly k ones. 

You are not allowed to use leading zeros for x and y. 

Input

The only line contains three integers a, b, and k (0 ≤ a; 1 ≤ b; 0 ≤ k ≤ a + b ≤ 2 ⋅ 10^5) — the number of zeroes, ones, and the number of ones in the result.

Output

If it's possible to find two suitable integers, print "Yes" followed by x and y in base-2.

Otherwise print "No".

If there are multiple possible answers, print any of them.

Examples

Input


4 2 3


Output


Yes
101000
100001


Input


3 2 1


Output


Yes
10100
10010


Input


3 2 5


Output


No

Note

In the first example, x = 101000_2 = 2^5 + 2^3 = 40_{10}, y = 100001_2 = 2^5 + 2^0 = 33_{10}, 40_{10} - 33_{10} = 7_{10} = 2^2 + 2^1 + 2^0 = 111_{2}. Hence x-y has 3 ones in base-2.

In the second example, x = 10100_2 = 2^4 + 2^2 = 20_{10}, y = 10010_2 = 2^4 + 2^1 = 18, x - y = 20 - 18 = 2_{10} = 10_{2}. This is precisely one 1.

In the third example, one may show, that it's impossible to find an answer.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.TreeMap;

import javax.swing.text.html.HTMLDocument.Iterator;

/*
 * Printing Euler Tour in an Eulerian Graph
 */
public class E {

	public static void main(String[] args) throws IOException, InterruptedException {
		Scanner sc = new Scanner(System.in);
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		PrintWriter pw = new PrintWriter(System.out);

		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		if (k == 0) {
			int[] a = new int[n + m];
			int[] b = new int[n + m];
			for (int i = 0; i < a.length; i++) {
				if (i >= m) {
					a[i] = 0;
					b[i] = 0;
				} else {
					a[i] = 1;
					b[i] = 1;

				}
			}
			////////
			pw.println("Yes");
			for (int i = 0; i < a.length; i++) {
				pw.print(a[i]);
			}
			pw.println();
			for (int i = 0; i < b.length; i++) {
				pw.print(b[i]);
			}
			pw.println();

		} else if (n + m - 1 > k && n > 0 && m > 1) {
			int[] a = new int[n + m];
			int[] b = new int[n + m];
			for (int i = 0; i < Math.min(m - 1, k); i++) {
				a[k - i] = 1;
				b[k - i] = 1;
			}
			b[k] = 0;
			b[0] = 1;
			for (int i = 0; i < Math.max(m - k, 1); i++) {
				a[a.length - 1 - i] = 1;
				b[a.length - 1 - i] = 1;
			}
			//
			pw.println("Yes");
			for (int i = 0; i < a.length; i++) {
				pw.print(a[a.length - i - 1]);
			}
			pw.println();
			for (int i = 0; i < b.length; i++) {
				pw.print(b[b.length - i - 1]);
			}

		} else
			pw.println("No");

		pw.flush();

//		 else if (n >= k && m >= 2) {
//				int[] a = new int[n + m];
//				int[] b = new int[n + m];
//				m--;
//				a[a.length - k - 1] = 1;
//				b[a.length - 1] = 1;
//				for (int i = 0; i < m; i++) {
//					a[i] = 1;
//					b[i] = 1;
//				}
//				pw.println("Yes");
//				for (int i = 0; i < a.length; i++) {
//					pw.print(a[i]);
//				}
//				pw.println();
//				for (int i = 0; i < b.length; i++) {
//					pw.print(b[i]);
//				}
//				pw.println();
//			} else if (n >= 2 && m >= k) {
//				int[] a = new int[n + m];
//				int[] b = new int[n + m];
//				for (int i = 0; i < k - 1; i++) {
//					b[b.length - 1 - i] = 1;
//				}
//				a[a.length - k - 1] = 1;
//				for (int j = 1; j < k - 1; j++) {
//					a[a.length - 1 - j] = 1;
//				}
//				m -= k - 1;
//				for (int i = 0; i < m; i++) {
//					a[i] = 1;
//					b[i] = 1;
//				}
//				//
//				pw.println("Yes");
//				for (int i = 0; i < a.length; i++) {
//					pw.print(a[i]);
//				}
//				pw.println();
//				for (int i = 0; i < b.length; i++) {
//					pw.print(b[i]);
//				}
//				pw.println();
//			}
	}

	static class pair implements Comparable<pair> {
		int x;
		int y;

		public pair(int d, int u) {
			x = d;
			y = u;
		}

		@Override
		public int compareTo(pair o) {

			return o.x - x;
		}

	}

	static ArrayList<Integer>[] adjList;
	static LinkedList<Integer> tour;
	static ArrayList<Integer>[] g;

	static ArrayList<Integer> primes; // generated by sieve

	/*
	 * 1. Generating a list of prime factors of N
	 */
	static HashMap<Integer, Integer> primeFactors(int N) // O(sqrt(N) / ln sqrt(N))
	{
		HashMap<Integer, Integer> factors = new HashMap<>(); // take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while (p * p <= N) {
			int c = 0;
			while (N % p == 0) {
				N /= p;
				c++;
			}
			if (c > 0)
				factors.put(p, c);
			if (idx + 1 == primes.size())
				break;
			p = primes.get(++idx);
		}

		if (N != 1) // last prime factor may be > sqrt(N)
			factors.put(N, 1); // for integers whose largest prime factor has a power of 1
		return factors;
	}

	static int[] isComposite;

	static void sieve(int N) // O(N log log N)
	{
		isComposite = new int[N + 1];
		isComposite[0] = isComposite[1] = 1; // 0 indicates a prime number
		primes = new ArrayList<Integer>();

		for (int i = 2; i <= N; ++i) // can loop till i*i <= N if primes array is not needed O(N log log sqrt(N))
			if (isComposite[i] == 0) // can loop in 2 and odd integers for slightly better performance
			{
				primes.add(i);
				if (1l * i * i <= N)
					for (int j = i * i; j <= N; j += i) // j = i * 2 will not affect performance too much, may alter in
														// modified sieve
						isComposite[j] = 1;
			}
	}

	static HashSet<Integer> hs;
	static int[] a;
	static long[] cum;

	static void divide(int s, int e) {
//		System.out.println(s + " " + e);
		if (e == -1 || s > e)
			return;
		if (cum[e + 1] - cum[s] <= 1e9)
			hs.add((int) (cum[e + 1] - cum[s]));
//		System.out.println(cum[e + 1] - cum[s]);
		if (e == s)
			return;
		int temp = a[e] + a[s] >> 1;
		int lo = s;
		int hi = e;
		int ans = -1;
		while (lo <= hi) {
			int mid = lo + hi >> 1;
			if (a[mid] <= temp) {
				ans = mid;
				lo = mid + 1;
			} else
				hi = mid - 1;
		}
		if (ans == -1 || ans == e)
			return;
		divide(s, ans);
		divide(ans + 1, e);
	}

	static int power(int x, int y, int p) {

		// Initialize result
		int res = 1;

		// Update x if it is more than or
		// equal to p
		x = x % p;

		while (y > 0) {

			// If y is odd, multiply x
			// with result
			if (y % 2 == 1)
				res = (int) ((res * 1l * x) % p);

			// y must be even now
			y = y >> 1; // y = y/2
			x = (int) ((x * 1l * x) % p);
		}

		return res;
	}

	// Returns n^(-1) mod p
	static int modInverse(int n, int p) {
		return power(n, p - 2, p);
	}

	// Returns nCr % p using Fermat's
	// little theorem.
	static int nCrModPFermat(int n, int r, int p) {

		if (n < r)
			return 0;
		// Base case
		if (r == 0)
			return 1;

		// Fill factorial array so that we
		// can find all factorial of r, n
		// and n-r
		return (int) (((fac[n] * 1l * modInverse(fac[r], p)) % p * modInverse(fac[n - r], p) % p) % p);
	}

	static int[] fac;

	static void init() {
		fac = new int[200001];
		fac[0] = 1;
		for (int i = 1; i <= 200000; i++)
			fac[i] = (int) ((fac[i - 1] * 1l * i) % mod);
	}

	static int mod = 1000000007;
	static long ans = 10000000000l;

	static void find(int i, int sum, String s, int t) {
		if (sum == t) {
			ans = Math.min(ans, Integer.parseInt(s));
			return;
		}
//		System.out.println(s);
		if (i == 0)
			return;
		find(i - 1, sum, s, t);
		find(i - 1, sum + i, i + s, t);

	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}