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.

Source: codeforces | Difficulty: HARD
Tags: Bit manipulation

Constructive algorithms

Mathematics

Greedy algorithms


Solutions:
(a, b, k) = list(map(int, input().split()))
if a == 0 and k != 0:
	print('No')
elif k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif b == 1 or k > a + b - 2:
	print('No')
else:
	shift = a + b - 2 - k
	print('Yes')
	ans_1 = ['1' for _ in range(b)] + ['0' for _ in range(a)]
	ans_2 = ['1'] + ['0'] + ['1' for _ in range(b - 2)] + ['0' for _ in range(a - 1)] + ['1']
	if shift <= a - 1:
		ans_2 = ['1'] + ['0'] + ['1' for _ in range(b - 2)] + ['0' for _ in range(a - 1 - shift)] + ['1'] + ['0' for _ in range(shift)]
	else:
		ans_2 = ['1'] + ['1' for _ in range(shift - (a - 1))] + ['0'] + ['1' for _ in range(b - 2 - (shift - (a - 1)))] + ['1'] + ['0' for _ in range(a - 1)]
	print(''.join(ans_1))
	print(''.join(ans_2))


import sys
(a, b, k) = [int(_) for _ in input().split()]
if b == 1:
	if k != 0:
		print('No')
	else:
		print('Yes')
		print('1' + '0' * a)
		print('1' + '0' * a)
	sys.exit()
if a == 0:
	if k != 0:
		print('No')
	else:
		print('Yes')
		print('1' * b)
		print('1' * b)
	sys.exit()
if k > a + b - 2:
	print('No')
	sys.exit()
bin1 = ['1'] + ['0'] * (a + b - 1)
bin2 = ['1'] + ['0'] * (a + b - 1)
bin1[1] = '1'
bin2[1 + k] = '1'
shit = b - 2
for i in range(a + b):
	if shit == 0:
		break
	if i != 0 and i != 1 and (i != 1 + k):
		bin1[i] = '1'
		bin2[i] = '1'
		shit -= 1
print('Yes')
print(''.join(bin1))
print(''.join(bin2))


(z, o, k) = map(int, input().split())
if k == 0:
	print('YES')
	print('1' * o + '0' * z)
	print('1' * o + '0' * z)
elif z == 0 or o == 0:
	print('NO')
elif z >= 1 and o >= 2 and (k < z + o - 1):
	print('YES')
	z -= 1
	o -= 2
	zz = min(k - 1, z)
	oo = min(k - 1 - zz, o)
	a = '1' * (o - oo) + '11' + '0' * zz + '1' * oo + '0' + '0' * (z - zz)
	b = '1' * (o - oo) + '10' + '0' * zz + '1' * oo + '1' + '0' * (z - zz)
	print(a)
	print(b)
else:
	print('NO')


(a, b, k) = map(int, input().split(' '))
b -= 1
if k == 0:
	print('Yes')
	print('1' * (b + 1) + '0' * a)
	print('1' * (b + 1) + '0' * a)
elif a + b <= k:
	print('No')
elif a == 0 or b == 0:
	print('No')
else:
	print('Yes')
	if a + b - k <= a:
		print('1' * (b + 1) + '0' * a)
		print('10' + '1' * (b - 1) + '0' * (k - b) + '1' + '0' * (a + b - k - 1))
	else:
		print('1' * (k + 1) + '0' + '1' * (b - k) + '0' * (a - 1))
		print('10' + '1' * b + '0' * (a - 1))


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
for _ in range(1):
	(zero, one, k) = I()
	if k == 0:
		x = '1' * one + '0' * zero
		print('Yes')
		print(x)
		print(x)
		break
	one -= 1
	if (one and zero) and k <= zero + one - 1:
		x = '1' * (one + 1) + '0' * zero
		if k <= zero:
			y = '1' * one + '0' * k + '1' + '0' * (zero - k)
		else:
			rm = k - zero
			y = '1' * (one - rm) + '0' + '1' * rm + '0' * (zero - 1) + '1'
		print('Yes')
		print(x)
		print(y)
	else:
		print('No')


import os, sys
from io import BytesIO, IOBase

def main():
	(a, b, k) = map(int, input().split())
	if b == 1 or not a or (not k):
		if not k:
			print('Yes')
			print('1' * b + '0' * a)
			print('1' * b + '0' * a)
		else:
			print('No')
	elif k > a + b - 2:
		print('No')
	else:
		print('Yes')
		x = min(b - 2, k - 1)
		y = k - 1 - x
		print('1' * b + '0' * a)
		print('1' + '1' * (b - 2 - x) + '0' + '1' * x + '0' * y + '1' + '0' * (a - 1 - y))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import sys, math, itertools
from collections import Counter, deque, defaultdict
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush, heapify, nlargest
from copy import deepcopy
mod = 10 ** 9 + 7
INF = float('inf')

def inp():
	return int(sys.stdin.readline())

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

def inpl_1():
	return list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))

def inps():
	return sys.stdin.readline()

def inpsl(x):
	tmp = sys.stdin.readline()
	return list(tmp[:x])

def err(x):
	print(x)
	exit()

def ans(X, Y):
	print('YES')
	print(X)
	print(Y)
	exit()
(a, b, k) = inpl()
b -= 1
n = a + b
m = b
if n == m:
	if k != 0:
		err('NO')
	res = '1' * (b + 1)
	ans(res, res)
if m == 0:
	if k != 0:
		err('NO')
	res = '1' + '0' * a
	ans(res, res)
if n <= k:
	err('NO')
Z = list('1' * k + '0' * (n - k))
up = 0
Y = list('1' * m + '0' * a + '1') if m <= k else list('1' * k + '0' + '1' * (m - k) + '0' * (a - 1) + '1')
X = []
for i in range(n):
	now = up + int(Z[i]) + int(Y[i])
	(up, now) = (1 if now > 1 else 0, now % 2)
	X.append(str(now))
X.append('1')
ans(''.join(X[::-1]), ''.join(Y[::-1]))


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def main():
	(a, b, k) = map(int, input().split())
	if k == a + b:
		print('No')
		return
	x = '1' * b + '0' * a
	y = list(x)
	if k > a:
		y[-k - 1] = '0'
		y[-1] = '1'
	else:
		y[b - 1] = '0'
		y[b + k - 1] = '1'
	if y[0] == '0' or y.count('0') != a or y.count('1') != b:
		print('No')
		return
	print('Yes')
	print(x)
	print(''.join(y))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import collections
import string
import math
import copy
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
mo = 998244353

def exgcd(a, b):
	if not b:
		return (1, 0)
	(y, x) = exgcd(b, a % b)
	y -= a // b * x
	return (x, y)

def getinv(a, m):
	(x, y) = exgcd(a, m)
	return -1 if x == 1 else x % m

def comb(n, b):
	res = 1
	b = min(b, n - b)
	for i in range(b):
		res = res * (n - i) * getinv(i + 1, mo) % mo
	return res % mo

def quickpower(a, n):
	res = 1
	while n:
		if n & 1:
			res = res * a % mo
		n >>= 1
		a = a * a % mo
	return res

def dis(a, b):
	return abs(a[0] - b[0]) + abs(a[1] - b[1])

def getpref(x):
	if x > 1:
		return x * (x - 1) >> 1
	else:
		return 0

def orafli(upp):
	primes = []
	marked = [False for i in range(upp + 3)]
	for i in range(2, upp):
		if not marked[i]:
			primes.append(i)
		for j in primes:
			if i * j >= upp:
				break
			marked[i * j] = True
			if i % j == 0:
				break
	return primes

def read_list():
	return [int(i) for i in input().split()]

def read_int():
	s = input().split()
	if len(s) == 1:
		return int(s)
	else:
		return map(int, s)

def ask(s):
	print(f'? {s}', flush=True)

def answer(s):
	print(f'! {s}', flush=True)

def solve():
	(a, b, k) = read_int()
	if (not a or b == 1) and k != 0:
		print('No')
		return
	if k <= a:
		l1 = '1' * b + '0' * a
		l2 = '1' * (b - 1)
		l = ['0'] * (a + 1)
		l[k] = '1'
		print('Yes')
		print(l1)
		print(l2 + ''.join(l))
	elif k <= a + b - 2:
		l1 = '1' * b + '0' * a
		l2 = '10' + '1' * (b - 2)
		kk = k
		k -= b - 2
		if k > 0:
			l = ['0'] * (a + 1)
			l[k] = '1'
			l.pop(0)
			print('Yes')
			print(l1)
			print(l2 + ''.join(l))
		else:
			ll2 = list(l1)
			ll2[-kk - 1] = '0'
			ll2[-1] = '1'
			print('Yes')
			op2 = ''.join(ll2)
			if op2.count('1') != b or op2.count('0') != a:
				print('No')
				return
			print(l1)
			print(op2)
	else:
		print('No')
solve()


from sys import stdin, stdout
input = stdin.readline

def main(inp):
	(a, b, k) = inp
	if b == 1:
		if k != 0:
			print('No')
		else:
			print('Yes')
			print('1' * b + '0' * a)
			print('1' * b + '0' * a)
		return
	if a == 0:
		if k != 0:
			print('No')
		else:
			print('Yes')
			print('1' * b)
			print('1' * b)
		return
	if k == a + b:
		print('No')
		return
	if k == 0:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * b + '0' * a)
		return
	if k <= a:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
		return
	if k - a < b - 1:
		num = k - a
		print('Yes')
		print('1' * (b - num) + '0' * (a - 1) + '1' * num + '0')
		print('1' * (b - 1 - num) + '0' * a + '1' * num + '1')
		return
	print('No')
main(map(int, input().split()))


import sys
input = sys.stdin.readline
from collections import Counter
(a, b, k) = map(int, input().split())
if k == 0:
	x = y = '1' * b + '0' * a
	print('Yes')
	print(x)
	print(y)
elif a == 0 or b == 1:
	if k == 0:
		x = y = '1' * b + '0' * a
		print('Yes')
		print(x)
		print(y)
	else:
		print('No')
else:
	t = b - 2 + a
	if k > t:
		print('No')
	elif k >= b - 1:
		x = '1' * b + '0' * a
		y = '1' + '0' + '1' * (b - 2) + '0' * (k - b + 1) + '1' + '0' * (a + b - 2 - k)
		print('Yes')
		print(x)
		print(y)
	elif k > a:
		print('Yes')
		x = '1' + '1' * k + '0' + (b - k - 1) * '1' + (a - 1) * '0'
		y = '1' + '0' + k * '1' + (b - k - 1) * '1' + (a - 1) * '0'
		print(x)
		print(y)
	else:
		x = '1' * b + '0' * a
		y = '1' * (b - 1) + '0' * k + '1' + '0' * (a - k)
		print('Yes')
		print(x)
		print(y)


import sys
zz = 1
sys.setrecursionlimit(10 ** 5)
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')
di = [[-1, 0], [1, 0], [0, 1], [0, -1]]

def fori(n):
	return [fi() for i in range(n)]

def inc(d, c, x=1):
	d[c] = d[c] + x if c in d else x

def ii():
	return input().rstrip()

def li():
	return [int(xx) for xx in input().split()]

def fli():
	return [float(x) for x in input().split()]

def dadd(d, p, val):
	if p in d:
		d[p].append(val)
	else:
		d[p] = [val]

def gi():
	return [xx for xx in input().split()]

def gtc(tc, ans):
	print('Case #' + str(tc) + ':', ans)

def cil(n, m):
	return n // m + int(n % m > 0)

def fi():
	return int(input())

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

def prec(a, pre):
	for i in a:
		pre.append(pre[-1] + i)
	pre.pop(0)

def si():
	return list(input().rstrip())

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

def gh():
	sys.stdout.flush()

def isvalid(i, j, n, m):
	return 0 <= i < n and 0 <= j < m

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = 1
uu = t
while t > 0:
	t -= 1
	(a, b, k) = mi()
	w = k
	if min(a, b) >= 2 and k > a + b - 2:
		print('No')
	else:
		b -= 1
		a1 = '1'
		a2 = '1'
		if min(a, b) == 1:
			if k > max(a, b):
				print('No')
				exit(0)
		if min(a, b) == 0:
			if k == 0:
				print('Yes')
				if a == 0:
					print(a1 + '1' * b)
					print(a2 + '1' * b)
				else:
					print(a1 + '0' * a)
					print(a2 + '0' * a)
			else:
				print('No')
			exit(0)
		if k <= a:
			a1 += '1' + '0' * k
			a2 += '0' * k + '1'
			a1 += '0' * (a - k) + '1' * (b - 1)
			a2 += '0' * (a - k) + '1' * (b - 1)
		elif k <= b:
			a1 += '1' * k + '0'
			a2 += '0' + '1' * k
			a1 += '0' * (a - 1) + '1' * (b - k)
			a2 += '0' * (a - 1) + '1' * (b - k)
		else:
			if k == a + b - 1:
				a1 += '1' * b + '0' * a
				a2 += '0' + '1' * (b - 1) + '0' * (a - 1) + '1'
				print('Yes')
				print(a1)
				print(a2)
				exit(0)
			a1 += '1' + '0' * (a - 1)
			a2 += '0' * (a - 1) + '1'
			k -= a - 1
			a = 1
			b -= 1
			a1 += '1' * min(k, b) + '0'
			a2 += '0' + '1' * min(k, b)
			a1 += '0' * (a - 1) + '1' * (b - k)
			a2 += '0' * (a - 1) + '1' * (b - k)
		print('Yes')
		print(a1)
		print(a2)


(a, b, k) = input().split()
a = int(a)
b = int(b)
k = int(k)
z = a
o = b
n = a + b
s1 = []
s2 = []
for i in range(n):
	s1.append('0')
	s2.append('0')
s1[0] = '1'
s2[0] = '1'
b -= 1
if a == 0 and b == 0 and (k == 0):
	print('YES')
	print('1')
	print('1')
	exit(0)
if k > n - 2:
	print('NO')
	exit(0)
if b == 0:
	if k != 0:
		print('NO')
		exit(0)
flag = -1
first = True
i = n - 1
while b > 0 and i > 0:
	if first:
		i -= k
		s1[i] = '1'
		s2[n - 1] = '1'
		flag = i
		i -= 1
	else:
		s1[i] = '1'
		s2[i] = '1'
		i -= 1
	b -= 1
	first = False
i = n - 2
while i > flag and b > 0:
	s1[i] = '1'
	s2[i] = '1'
	b -= 1
	i -= 1
ca = 0
cb = 0
for idx in range(n):
	ca += 1 if s1[idx] == '1' else 0
	cb += 1 if s2[idx] == '1' else 0
if o != ca or o != cb:
	print('NO')
	exit(0)
ca = 0
cb = 0
for idx in range(n):
	ca += 1 if s1[idx] == '0' else 0
	cb += 1 if s2[idx] == '0' else 0
if z != ca or z != cb:
	print('NO')
	exit(0)
print('YES')
print(''.join(s1))
print(''.join(s2))


(a, b, k) = map(int, input().split())
(a, b) = (b, a)
k1 = k
if b == 0:
	if k == 0:
		print('Yes')
		print('1' * a)
		print('1' * a)
	else:
		print('No')
	exit(0)
if a == 1:
	if k == 0:
		print('Yes')
		print('1' + '0' * b)
		print('1' + '0' * b)
	else:
		print('No')
	exit(0)
s = '1' + '0' + (a - 2) * '1' + (b - 1) * '0' + '1'
f = '00'
for i in range(min(k, a - 2)):
	f += '1'
k -= min(k, a - 2)
while a + b - len(f) > k:
	f = f + '0'
while len(f) < a + b:
	f += '1'
f = '0b' + f
s = '0b' + s
f = f[2:]
f = '0b' + f
k = k1
if f[2:].count('1') != k or (bin(eval(f + '+' + s))[2:].count('1') != a and bin(eval(f + '+' + s))[2:].count('0') != b):
	print('No')
else:
	print('Yes')
	print(bin(eval(f + '+' + s))[2:])
	print(s[2:])


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline()

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

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

def N():
	return int(input())

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

def print_list(l):
	print(' '.join(map(str, l)))
(a, b, k) = RL()
if k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif k > a + b - 2 or a == 0 or b == 1:
	print('No')
else:
	s = '1' * (b - 1) + '0' * (a - 1)
	i = a + b - k - 1
	print('Yes')
	print(s[:i] + '1' + s[i:] + '0')
	print(s[:i] + '0' + s[i:] + '1')


(a, b, k) = map(int, input().split())
if b == 1 and k != 0:
	print('NO')
elif a == 0 and k != 0:
	print('NO')
elif k == 0:
	print('YES')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif k >= a + b - 1:
	print('NO')
elif k <= a:
	print('YES')
	print('1' * (b - 1) + '0' * (a - k) + '1' + '0' * k)
	print('1' * (b - 1) + '0' * a + '1')
else:
	print('YES')
	print('1' * b + '0' * a)
	print('1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1')


(a, b, k) = map(int, input().split())
if b == 1:
	if k == 0:
		print('Yes')
		print('1' + '0' * a)
		print('1' + '0' * a)
	else:
		print('No')
elif a == 0:
	if k == 0:
		print('Yes')
		print('1' * b)
		print('1' * b)
	else:
		print('No')
elif k <= a:
	print('Yes')
	LCP = (a - k) * '0' + (b - 2) * '1'
	zer = '0' * k
	print('1' + LCP + '1' + zer)
	print('1' + LCP + zer + '1')
elif a < k < a + b - 1:
	print('Yes')
	n = k - a
	m = b - 1 - n
	print('1' * b + '0' * a)
	print('1' * m + '0' + '1' * n + '0' * (a - 1) + '1')
else:
	print('No')


(a, b, k) = map(int, input().split())
if a == 0 or b == 1:
	if k != 0:
		print('No')
	elif a == 0 and b == 1:
		print('Yes\n1 1')
	elif a == 0:
		print(f"Yes\n{'1' * b} {'1' * b}")
	elif b == 1:
		print('Yes\n1' + '0' * a + ' ' + '1' + '0' * a)
elif a + b - 2 < k:
	print('No')
else:
	x = '1' * b + '0' * a
	if k <= a:
		print('Yes\n' + x + ' ' + '1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
	else:
		y = '1' * (b - (k - a) - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1'
		print(f'Yes\n{x} {y}')


(a, b, k) = map(int, input().strip().split())
if a == 0 or b == 1:
	if k == 0:
		print('Yes')
		x = ''
		for i in range(b):
			x += '1'
		for i in range(a):
			x += '0'
		print(x, x)
	else:
		print('No')
elif k <= a + b - 2:
	print('Yes')
	x = ''
	for i in range(b):
		x += '1'
	for i in range(a):
		x += '0'
	y = x
	y = list(y)
	mn = min(k, a)
	last = b - 1
	y[last] = '0'
	y[last + mn] = '1'
	if k >= mn:
		dif = k - mn
		p = dif
		last = b - 2
		while dif > 0:
			y[last] = '0'
			y[last + 1] = '1'
			dif -= 1
			last -= 1
	y2 = ''
	for c in y:
		y2 += c
	print(x, y2)
else:
	print('No')


import math

def getint():
	return [int(i) for i in input().split()]

def getstr():
	return [str(i) for i in input().split()]

def solve():
	(a, b, k) = getint()
	if k == 0:
		S = '1' * b + '0' * a
		print('Yes')
		print(S)
		print(S)
	elif a == 0 or b == 1:
		print('No')
	elif k <= a + b - 2:
		print('Yes')
		S = '1' * (b - 1) + '0' * (a - 1)
		ans = S[:a + b - k - 1] + '1' + S[a + b - k - 1:] + '0'
		print(ans)
		ans = S[:a + b - k - 1] + '0' + S[a + b - k - 1:] + '1'
		print(ans)
	else:
		print('No')
solve()


(a, b, k) = map(int, input().split())
if b == 1 or a == 0:
	if k == 0:
		print('YES')
		y = [1] * b + [0] * a
		print(*y, sep='')
		print(*y, sep='')
	else:
		print('NO')
elif k > a:
	if b >= 3 and k <= a + b - 2:
		x = [1] * b + [0] * a
		v = a + b - 2 - k + 1
		y1 = [1] + [1] * (b - 2) + [0] * (a - 1) + [1]
		y = []
		for i in range(a + b - 1):
			if i == v:
				y.append(0)
			y.append(y1[i])
		print('YES')
		print(*x, sep='')
		print(*y, sep='')
	else:
		print('NO')
else:
	print('YES')
	x = []
	y = [1] * (b - 1) + [0] * a + [1]
	for i in range(a + b - k - 1):
		if b > 1:
			x.append(1)
			b = b - 1
		else:
			x.append(0)
	x.append(1)
	for i in range(k):
		x.append(0)
	print(*x, sep='')
	print(*y, sep='')


from sys import stdin, stdout
input = stdin.readline
(a, b, k) = map(int, input().split())
if k == 0:
	s1 = '1' * b + '0' * a
	s2 = '1' * b + '0' * a
	a = 0
	b = 0
else:
	s1 = '1'
	s2 = '1'
	b -= 1
	if a < k and a > 0:
		s = '1' * (k - a) + '0' * (a - 1)
		s1 += '1' + s + '0'
		s2 += '0' + s + '1'
		b -= k - a + 1
		a = 0
	else:
		s1 += '1' + '0' * k
		s2 += '0' * k + '1'
		b -= 1
		a -= k
	if b > 0:
		s1 += '1' * b
		s2 += '1' * b
	if a > 0:
		s1 += '0' * a
		s2 += '0' * a
if a < 0 or b < 0:
	print('NO')
else:
	print('YES')
	print(s1)
	print(s2)


(zeroes, ones, k) = map(int, input().split())
s = [0] * (zeroes + ones)
t = [0] * (zeroes + ones)
n = zeroes + ones
exists = False
if k == 0:
	s = [1] * ones + [0] * zeroes
	t = s.copy()
	exists = True
elif zeroes:
	s[0] = 1
	t[0] = 1
	ones -= 1
	t[n - 1] = 1
	diff = min(k, zeroes)
	k -= diff
	i = n - diff - 1
	ones -= 1
	while k and ones and (i > 0):
		s[i] = 1
		t[i] = 1
		i -= 1
		k -= 1
		ones -= 1
	s[i] = 1
	t[i] = 0
	i -= 1
	while ones and i > 0:
		s[i] = 1
		t[i] = 1
		i -= 1
		ones -= 1
	if not k and (not ones):
		exists = True
print('Yes' if exists else 'No')
if exists:
	print(''.join(map(str, s)))
	print(''.join(map(str, t)))


(a, b, k) = map(int, input().split())
s1 = '1'
s2 = '1'
if b == 1:
	if k == 0:
		print('Yes')
		print('1' + '0' * a)
		print('1' + '0' * a)
		exit(0)
	print('No')
	exit()
pos1 = 1
pos2 = 1 + k
s1 = list('0' * (a + b))
s2 = list('0' * (a + b))
s1[0] = s2[0] = '1'
try:
	s1[pos1] = '1'
	s2[pos2] = '1'
	have = b - 2
	for i in range(a + b):
		if not have:
			break
		if s1[i] == '0' and s2[i] == '0':
			have -= 1
			s1[i] = s2[i] = '1'
	if have != 0:
		print('No')
		exit(0)
except IndexError:
	print('No')
	exit(0)
try:
	s1 = ''.join(s1)
	s2 = ''.join(s2)
	m = int(s1, 2)
	n = int(s2, 2)
	c = bin(m - n)[2:]
	assert c.count('1') == k
except Exception as e:
	print('No')
	exit(0)
print('Yes')
print(s1)
print(s2)


def main():
	(a, b, k) = readIntArr()
	if k == 0:
		x = b * '1' + a * '0'
		print('Yes')
		print(x)
		print(x)
	elif k >= a + b - 1:
		print('No')
	elif not (a >= 1 and b >= 2):
		print('No')
	else:
		n = a + b
		x = [None for _ in range(n)]
		y = [None for _ in range(n)]
		x[0] = y[0] = '1'
		x[n - 1] = '0'
		y[n - 1] = '1'
		x[n - k - 1] = '1'
		y[n - k - 1] = '0'
		a -= 1
		b -= 2
		for i in range(n):
			if x[i] == None:
				if a > 0:
					x[i] = '0'
					y[i] = '0'
					a -= 1
				else:
					x[i] = '1'
					y[i] = '1'
		print('Yes')
		print(''.join(x))
		print(''.join(y))
	return
import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]
inf = float('inf')
MOD = 10 ** 9 + 7
main()


import sys
from sys import stdin
tt = 1
for loop in range(tt):
	(a, b, k) = map(int, stdin.readline().split())
	if k == 0:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * b + '0' * a)
	elif a == 0:
		if k > 0:
			print('No')
		else:
			print('Yes')
			print('1' * b)
			print('1' * b)
	elif a + b - 1 <= k:
		print('No')
	else:
		x = [None] * (a + b)
		y = [None] * (a + b)
		x[k] = '1'
		y[k] = '0'
		x[0] = '0'
		y[0] = '1'
		a -= 1
		b -= 1
		for i in range(len(x)):
			if x[i] != None:
				continue
			if a > 0:
				x[i] = '0'
				y[i] = '0'
				a -= 1
			else:
				x[i] = '1'
				y[i] = '1'
		x.reverse()
		y.reverse()
		x = ''.join(x)
		y = ''.join(y)
		if x[0] == y[0] == '1':
			print('Yes')
			print(x)
			print(y)
		else:
			print('No')


from sys import stdin, stdout

def yes(x, y):
	stdout.write('Yes\n')
	stdout.write(''.join(map(str, x)))
	stdout.write('\n')
	stdout.write(''.join(map(str, y)))
	stdout.write('\n')

def no():
	stdout.write('No\n')

def check(x, y):
	x = int(f"0b{''.join(map(str, x))}", base=2)
	y = int(f"0b{''.join(map(str, y))}", base=2)
	print(bin(x - y))
(a, b, k) = map(int, stdin.readline().split())
if k == 0:
	lst = [1] * b + [0] * a
	yes(lst, lst)
elif b == 1 or k > a + b - 2:
	no()
else:
	x = [1] + [0] * (a + b - 1)
	y = x.copy()
	on_x = 1
	on_y = 1 + k
	x[on_x] = 1
	y[on_y] = 1
	ones_left = b - 2
	counter = 2
	try:
		while ones_left > 0:
			if counter != on_y:
				ones_left -= 1
				x[counter] = 1
				y[counter] = 1
			counter += 1
		yes(x, y)
	except:
		no()


(a, b, k) = map(int, input().split())
if a == 0:
	if k == 0:
		print('YES')
		print('1' * b)
		print('1' * b)
	else:
		print('NO')
	exit(0)
if b == 1:
	if k == 0:
		print('YES')
		print('1' + '0' * a)
		print('1' + '0' * a)
	else:
		print('NO')
	exit(0)
if k > a + b - 2:
	print('NO')
	exit(0)
print('YES')
print('1' * b + '0' * a)
if k <= a:
	print('1' * (b - 1) + k * '0' + '1' + '0' * (a - k))
	exit(0)
t = k - a
print('1' * (b - t - 1) + '0' + '1' * t + '0' * (a - 1) + '1')


import collections

def solveTestCase():
	(a, b, k) = [int(i) for i in input().split()]
	if (a == 0 or b == 1) and k != 0 or (k > a + b - 2 and k > 0):
		print('NO')
	else:
		print('YES')
		x = [1] * b + [0] * a
		y = [1] * b + [0] * a
		p = b - 1
		m = min(a, k)
		y[p] = 0
		y[p + m] = 1
		k -= m
		while k > 0:
			k -= 1
			y[p] = 1
			y[p - 1] = 0
			p -= 1
		for i in x:
			print(i, end='')
		print()
		for i in y:
			print(i, end='')
		print()
t = 1
while t > 0:
	t -= 1
	solveTestCase()


def solution():
	(a, b, k) = map(int, input().split())
	if k > max(a + b - 2, 0) or (b == 1 and k != 0) or (a == 0 and k != 0):
		print('No')
	elif k <= a:
		print('Yes', b * '1' + a * '0', (b - 1) * '1' + k * '0' + '1' + (a - k) * '0', sep='\n')
	else:
		print('Yes', b * '1' + a * '0', (b + a - k - 1) * '1' + '0' + (k - a) * '1' + (a - 1) * '0' + '1', sep='\n')
solution()


import math
import collections

def read_list() -> list:
	return [int(i) for i in input().strip().split()]

def read_num() -> int:
	return int(input().strip())
(a, b, k) = read_list()
n = a + b
ans1 = [1] + [0] * (n - 1)
ans2 = [1] + [0] * (n - 1)

def print_ans(ans):
	for i in ans:
		print(i, end='')
	print()
if k == 0:
	for i in range(b):
		ans1[i] = 1
		ans2[i] = 1
	print('Yes')
	print_ans(ans1)
	print_ans(ans2)
elif b == 1:
	print('No')
elif a == 0 and k != 0:
	print('No')
elif k > a + b - 2:
	print('No')
else:
	ans2[-1] = 1
	a -= 1
	b -= 2
	pos = n - 2
	for i in range(k - 1):
		if a > 0:
			a -= 1
		else:
			ans1[pos] = 1
			ans2[pos] = 1
			b -= 1
		pos -= 1
	ans1[pos] = 1
	pos -= 1
	for i in range(b):
		ans1[pos] = 1
		ans2[pos] = 1
		pos -= 1
	print('Yes')
	print_ans(ans1)
	print_ans(ans2)


import os, sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
try:
	(sys.stdin, sys.stdout) = (open('in.txt', 'r'), open('out.txt', 'w'))
except:
	pass
ii1 = lambda : int(sys.stdin.readline().strip())
is1 = lambda : sys.stdin.readline().strip()
iia = lambda : list(map(int, sys.stdin.readline().strip().split()))
isa = lambda : sys.stdin.readline().strip().split()
mod = int(1000000000.0 + 7)
from collections import *
from math import *
from collections import defaultdict as dd
R = range
(z, o, k) = iia()
s = '1' * o + '0' * z
if k == 0:
	print('Yes\n' + s + '\n' + s)
elif z == 0 or o == 1:
	if k == 0:
		print('Yes\n' + s + '\n' + s)
	else:
		print('No')
elif k <= z + o - 2:
	print('Yes')
	s = '1' * (o - 1) + '0' * (z - 1)
	print(f'{s[:z + o - k - 1]}1{s[z + o - k - 1:]}0')
	print(f'{s[:z + o - k - 1]}0{s[z + o - k - 1:]}1')
else:
	print('No')


(a, b, k) = map(int, input().split())
x = '1' * (b - 1) + '0' * (a - 1)
if k == 0:
	print('YES', '1' * b + '0' * a, '1' * b + '0' * a, sep='\n')
elif a + b - 2 >= k and b != 1 and (a != 0):
	print('YES', x[:a + b - 1 - k] + '1' + x[a + b - 1 - k:] + '0', x[:a + b - 1 - k] + '0' + x[a + b - 1 - k:] + '1', sep='\n')
else:
	print('NO')


(a, b, k) = map(int, input().strip().split())
if k == 0:
	S = '1' * b + '0' * a
	print('Yes\n' + S + '\n' + S)
elif a == 0 or b == 1:
	print('No')
elif k <= a + b - 2:
	S = '1' * (b - 1) + '0' * (a - 1)
	print(f'Yes\n{S[:a + b - k - 1]}1{S[a + b - k - 1:]}0\n{S[:a + b - k - 1]}0{S[a + b - k - 1:]}1')
else:
	print('No')


(a, b, k) = map(int, input().split())
n = a + b
if k == n:
	print('no')
elif k == 0:
	print('yes')
	s = ['1'] * b + ['0'] * a
	print(''.join(s))
	print(''.join(s))
elif a == 0:
	print('no')
elif k == n - 1:
	print('no')
elif k + 1 <= b:
	print('yes')
	res1 = ['1'] + ['1'] * k + ['0'] + ['1'] * (b - (k + 1)) + ['0'] * (a - 1)
	res2 = ['1', '0'] + ['1'] * k + ['1'] * (b - (k + 1)) + ['0'] * (a - 1)
	print(''.join(res1))
	print(''.join(res2))
elif b == 1:
	print('No')
else:
	print('yes')
	res1 = ['0'] + ['1'] * (b - 2) + ['0'] * (k - b + 1) + ['1'] + ['0'] * (n - k - 2) + ['1']
	res2 = ['1'] * (b - 1) + ['0'] * a + ['1']
	print(''.join(res1[::-1]))
	print(''.join(res2[::-1]))


def mnm(a, b, k):
	if k == 0:
		s = '1' * b + '0' * a
		return [s, s]
	if a < 1 or b < 2:
		return ['0', '0']
	if k > a + b - 2:
		return ['0', '0']
	if a < k:
		s1 = '1' + '1' * (a + b - k - 2) + '1' + '1' * (k - a) + '0' * (a - 1) + '0'
		s2 = '1' + '1' * (a + b - k - 2) + '0' + '1' * (k - a) + '0' * (a - 1) + '1'
	else:
		s1 = '1' + '1' * (b - 2) + '0' * (a - k) + '1' + '0' * (k - 1) + '0'
		s2 = '1' + '1' * (b - 2) + '0' * (a - k) + '0' + '0' * (k - 1) + '1'
	return [s1, s2]
(a, b, k) = map(int, input().split())
w = mnm(a, b, k)
if w[0] == '0':
	print('NO')
else:
	print('YES')
	print(w[0])
	print(w[1])


(a, b, k) = map(int, input().split())
b -= 1
if a == 0:
	if k == 0:
		x = '1' * b
		y = '1' * b
	else:
		x = None
		y = None
elif b == 0:
	if k == 0:
		x = '0' * a
		y = '0' * a
	else:
		x = None
		y = None
elif k >= a + b:
	x = None
	y = None
elif k <= b:
	x = '0' * (a - 1) + '1' * k + '0' + '1' * (b - k)
	y = '0' * a + '1' * b
else:
	x = '0' * (a + b - 1 - k) + '1' + '0' * (k - b) + '1' * (b - 1) + '0'
	y = '0' * a + '1' * b
if x is None:
	print('No')
else:
	print('Yes')
	x = '1' + x
	y = '1' + y
	print(x)
	print(y)


import sys
input = sys.stdin.readline

def stupid(a, b, k):
	if a + b == 1:
		if k == 0:
			return ('YES', '0' if a == 1 else '1', '0' if a == 1 else '1')
		return ('NO', 0, 0)
	n = a + b
	for x in range(2 ** n - 1, 2 ** (n - 1) - 1, -1):
		xb = bin(x)
		if xb.count('0') == a + 1 and xb.count('1') == b:
			for y in range(x, 2 ** n):
				yb = bin(y)
				if yb.count('1') == b and yb.count('0') == a + 1:
					c = bin(y - x)
					if c.count('1') == k:
						return ('YES', bin(y)[2:], bin(x)[2:])
	return ('NO', 0, 0)

def smart(a, b, k):
	c = '1' * b + '0' * a
	if a + b == 1:
		if k == 0:
			return ('YES', c, c)
		return ('NO', 0, 0)
	if b == 1:
		if k == 0:
			return ('YES', c, c)
		return ('NO', 0, 0)
	if k <= a:
		return ('YES', c, '1' * (b - 1) + '0' * (a - (a - k)) + '1' + '0' * (a - k))
	elif a != 0 and b >= 3 and (k >= a + 1) and (k <= a + b - 2):
		t = a + b - 2
		return ('YES', c, '1' * (t - k + 1) + '0' + '1' * (b - (t - k + 1) - 1) + '0' * (a - 1) + '1')
	return ('NO', 0, 0)

def check(ans, a, b, k):
	if ans[0] == 'NO':
		return True
	(x, y) = (ans[1], ans[2])
	if x.count('0') == a and y.count('0') == a and (x.count('1') == b) and (y.count('1') == b):
		xv = int(x, 2)
		yv = int(y, 2)
		z = xv - yv
		if z >= 0:
			return bin(z).count('1') == k
	return False

def solve():
	(a, b, k) = map(int, input().split())
	ans2 = smart(a, b, k)
	if ans2[0] == 'NO':
		print('NO')
		return
	else:
		print('YES')
		print(ans2[1])
		print(ans2[2])
solve()


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
(a, b, k) = list(map(int, input().split()))
if a == 0:
	if k == 0:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * b + '0' * a)
	else:
		print('No')
elif k > a:
	if k > a + b:
		print('No')
	else:
		ans1 = b * '1' + a * '0'
		ans2 = (a + b - k - 1) * '1' + '0' + (k - a) * '1' + (a - 1) * '0' + '1'
		if ans1[0] == '1' and ans2[0] == '1':
			print('Yes')
			print(ans1)
			print(ans2)
		else:
			print('No')
elif k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif k > 0 and b == 0:
	print('No')
else:
	ans1 = (b - 1) * '1' + (a - k) * '0' + '1' + '0' * k
	ans2 = (b - 1) * '1' + (a - k) * '0' + '0' * k + '1'
	if ans1[0] == '0' or ans2[0] == '0':
		print('No')
	else:
		print('Yes')
		print(ans1)
		print(ans2)


(a, b, c) = map(int, input().split())
if c == 0:
	print('YES')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif c > a + b - 2 or b < 2 or a < 1:
	print('NO')
else:
	print('YES')
	s1 = '1'
	s2 = '1'
	ost = a + b - 2 - c
	while a > 1 and ost > 0:
		s1 += '0'
		s2 += '0'
		a -= 1
		ost -= 1
	while b > 2 and ost > 0:
		s1 += '1'
		s2 += '1'
		b -= 1
		ost -= 1
	b -= 2
	s1 += '1'
	s2 += '0'
	s1 += '1' * b + '0' * a
	s2 += '1' * b + '0' * (a - 1) + '1'
	print(s1)
	print(s2)


import sys
from collections import defaultdict as dd
from collections import Counter as cc
from queue import Queue
import math
import itertools
import functools
from operator import ixor
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
(a, b, k) = map(int, input().split())
if a == 0:
	if k == 0:
		print('Yes')
		print('1' * b)
		print('1' * b)
	else:
		print('No')
elif k > a:
	if b == 1 and k > 0:
		print('No')
	elif b == 1 and k == 0:
		print('Yes')
		print('1' + '0' * a)
		print('1' + '0' * a)
	elif k > a + b - 2:
		print('No')
	else:
		print('Yes')
		q = ''
		q = q + '1'
		q = q + '1' * (b - 1)
		q = q + '0' * a
		w = ''
		w = w + '1' * (b - 1 - k + a)
		w = w + '0'
		w = w + '1' * (k - a)
		w = w + '0' * (a - 1)
		w = w + '1'
		print(q)
		print(w)
elif b == 1 and k > 0:
	print('No')
elif b == 1 and k == 0:
	print('Yes')
	print('1' + '0' * a)
	print('1' + '0' * a)
else:
	print('Yes')
	q = ''
	q = q + '1'
	q = q + '0' * (a - k)
	q = q + '1' * (b - 1)
	q = q + '0' * k
	w = ''
	w = w + '1'
	w = w + '0' * (a - k)
	w = w + '1' * (b - 2)
	w = w + '0' * k
	w = w + '1'
	print(q)
	print(w)


import os
import sys
from io import BytesIO, IOBase
import math
import itertools
import bisect
import heapq

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n

def p2(n):
	c = 0
	while n % 2 == 0:
		n //= 2
		c += 1
	return c

def seive(n):
	primes = [True] * (n + 1)
	primes[1] = primes[0] = False
	for i in range(2, n + 1):
		if primes[i]:
			for j in range(i + i, n + 1, i):
				primes[j] = False
	p = []
	for i in range(0, n + 1):
		if primes[i]:
			p.append(i)
	return p

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def denofactinverse(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return pow(fac, m - 2, m)

def numofact(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return fac

def chk(n, d):
	if str(d) in str(n):
		return True
	return False
(b, a, k) = map(int, input().split())
if a == 1 or b == 0:
	if k == 0:
		print('Yes')
		print('1' * a + '0' * b)
		print('1' * a + '0' * b)
	else:
		print('No')
elif k > a + b - 2:
	print('No')
else:
	s1 = '1' * a + '0' * b
	if k <= b:
		s2 = '1' * (a - 1) + '0' * k + '1' + '0' * (b - k)
	else:
		dis = a + b - 2 - k
		s2 = '1' * (dis + 1) + '0' + '1' * (a - dis - 2) + '0' * (b - 1) + '1'
	print('Yes')
	print(s1)
	print(s2)


import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.buffer.readline())

def MI():
	return map(int, sys.stdin.buffer.readline().split())

def LI():
	return list(map(int, sys.stdin.buffer.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def BI():
	return sys.stdin.buffer.readline().rstrip()

def SI():
	return sys.stdin.buffer.readline().rstrip().decode()
inf = 10 ** 16
md = 10 ** 9 + 7
(a, b, k) = MI()
if a == 0:
	if k == 0:
		print('Yes')
		s = '1' * b
		print(s)
		print(s)
	else:
		print('No')
	exit()
if b == 1:
	if k == 0:
		print('Yes')
		s = '1' + '0' * a
		print(s)
		print(s)
	else:
		print('No')
	exit()
if k > a + b - 2:
	print('No')
	exit()
s = [1] * b + [0] * a
t = [1] * b + [0] * a
cur = min(k, a)
t[b - 1] = 0
t[b - 1 + cur] = 1
i = b - 2
for _ in range(k - cur):
	t[i] = 0
	t[i + 1] = 1
	i -= 1
print('Yes')
print(*s, sep='')
print(*t, sep='')


import sys
input = sys.stdin.readline
import math
import copy
(a, b, k) = map(int, input().split())
x = []
y = []
if b == 1:
	if k == 0:
		print('Yes')
		x.append('1')
		y.append('1')
		for i in range(a):
			x.append('0')
			y.append('0')
		print(''.join(x))
		print(''.join(y))
	else:
		print('No')
elif a == 0:
	if k == 0:
		print('Yes')
		for i in range(b):
			x.append('1')
			y.append('1')
		print(''.join(x))
		print(''.join(y))
	else:
		print('No')
elif k <= a + b - 2:
	print('Yes')
	if k == 0:
		for i in range(b):
			x.append('1')
			y.append('1')
		for i in range(a):
			x.append('0')
			y.append('0')
		print(''.join(x))
		print(''.join(y))
		exit()
	a -= 1
	b -= 2
	x.append('1')
	y.append('1')
	x.append('1')
	y.append('0')
	for i in range(k - 1):
		if a > 0:
			x.append('0')
			y.append('0')
			a -= 1
		else:
			x.append('1')
			y.append('1')
			b -= 1
	x.append('0')
	y.append('1')
	for i in range(b):
		x.append('1')
		y.append('1')
	for i in range(a):
		x.append('0')
		y.append('0')
	print(''.join(x))
	print(''.join(y))
else:
	print('No')


def solve():
	global x, y
	if b == 1 or a == 0 or k == 0:
		if k > 0:
			return print('No')
		print('Yes')
		x = '1' * b + '0' * a
		print(x + '\n' + x)
		return
	if k >= a + b - 1:
		return print('No')
	c = min(k - 1, a - 1)
	d = max(0, k - 1 - c)
	x = '1' + '1' + '0' * c + '1' * d + '0' + '0' * (a - 1 - c) + '1' * (b - 2 - d)
	y = '1' + '0' + '0' * c + '1' * d + '1' + '0' * (a - 1 - c) + '1' * (b - 2 - d)
	print('Yes')
	print(x + '\n' + y)
check = lambda x, y: bin(int(x, 2) - int(y, 2))[2:]
read = lambda : map(int, input().split())
(a, b, k) = read()
solve()


def answer(v):
	if (k >= a + b - 1 or b == 1) and k != 0:
		print('No')
		return
	(x, y) = (['0'] * (a + b), ['0'] * (a + b))
	stop = -1
	if k != 0:
		(x[k], y[0]) = ('1', '1')
		v -= 1
		stop += 1
	for i in range(a + b - 1, stop, -1):
		if v == 0:
			break
		if not (x[i] == '1' or y[i] == '1'):
			x[i] = '1'
			y[i] = '1'
			v -= 1
	if v == 0:
		print('Yes')
		print(''.join(x[::-1]))
		print(''.join(y[::-1]))
	else:
		print('No')
(a, b, k) = map(int, input().split())
answer(b)


import sys, functools, collections, bisect, math, heapq
input = sys.stdin.readline
sys.setrecursionlimit(100000)
for _ in range(1):
	(a, b, k) = map(int, input().strip().split())
	if k == 0:
		print('YES')
		print('1' * b + '0' * a)
		print('1' * b + '0' * a)
	elif k > a + b - 2 or b == 1:
		print('NO')
	elif k <= b - 1:
		x = b - 1 - k
		if a:
			print('YES')
			print('1' * b + '0' * a)
			print('1' * (x + 1) + '0' + '1' * k + '0' * (a - 1))
		else:
			print('NO')
	else:
		x = k - b + 1
		print('YES')
		print('1' * b + '0' * a)
		print('10' + '1' * (b - 2) + '0' * x + '1' + '0' * (a - x - 1))


(a, b, k) = map(int, input().split())
if k != 0 and (b == 1 or a == 0) or a < min(k, k - b + 2):
	print('No')
else:
	print('Yes')
	print('1' * b + '0' * a)
	if k <= a:
		print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
	else:
		print('1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1')


from sys import stdin, stdout
t = 1
for _ in range(t):
	(a, b, k) = map(int, input().split())
	if a == 0 and k == 0:
		print('YES')
		val = ['1' for i in range(b)]
		s = ''.join(val)
		print(s)
		print(s)
		continue
	if a == 0:
		print('NO')
		continue
	if k > a + b - 2:
		print('NO')
		continue
	if b == 1:
		if k != 0:
			print('NO')
			continue
		print('YES')
		out = ['1']
		for i in range(a):
			out.append('0')
		s = ''.join(out)
		print(s)
		print(s)
		continue
	if k == 0:
		print('YES')
		val = []
		for i in range(b):
			val.append('1')
		for i in range(a):
			val.append('0')
		s = ''.join(val)
		print(s)
		print(s)
		continue
	val1 = []
	val2 = []
	if k <= a:
		val1 = []
		val2 = []
		for i in range(b):
			val1.append('1')
			if i == b - 1:
				val2.append('0')
			else:
				val2.append('1')
		count = 0
		for i in range(a):
			val1.append('0')
			count += 1
			if count == k:
				val2.append('1')
			else:
				val2.append('0')
		s1 = ''.join(val1)
		s2 = ''.join(val2)
		print('YES')
		print(s1)
		print(s2)
		continue
	for i in range(b):
		val1.append('1')
	for i in range(a):
		val1.append('0')
	val2.append('1')
	c = 0
	for i in range(a - 1):
		val2.append('0')
	k -= a
	used = 1
	for i in range(k):
		used += 1
		val2.append('1')
	val2.append('0')
	for i in range(b - used):
		val2.append('1')
	val2 = val2[::-1]
	s1 = ''.join(val1)
	s2 = ''.join(val2)
	print('YES')
	print(s1)
	print(s2)


def check(a, b, k):
	if a == 0 or b == 1:
		if k == 0:
			return ('1' * b + '0' * a, '1' * b + '0' * a)
		return False
	if k >= a + b - 1:
		if k == 0:
			return ('1' * b + '0' * a, '1' * b + '0' * a)
		return False
	x = '1' * b + '0' * a
	y = '1' * (b - 1) + '0' * min(a, k) + '1' + max(0, a - k) * '0'
	if k > a:
		yL = list(y)
		(yL[b - 1], yL[b - (k - a + 1)]) = (yL[b - (k - a + 1)], yL[b - 1])
		y = ''.join(yL)
	return (x, y)
(a, b, k) = map(int, input().split())
if check(a, b, k):
	print('Yes')
	print(*check(a, b, k), sep='\n')
else:
	print('No')


def main():
	inp = input().rstrip().split(' ')
	(a, b, k) = (int(inp[0]), int(inp[1]), int(inp[2]))
	x = []
	y = []
	if b == 1 or a == 0:
		if k == 0:
			print('Yes')
			for _ in range(b):
				x.append('1')
				y.append('1')
			for _ in range(a):
				x.append('0')
				y.append('0')
			print(''.join(x))
			print(''.join(y))
		else:
			print('No')
	elif k > a + b - 2:
		print('No')
	else:
		print('Yes')
		if k <= a:
			y.append('1')
			for _ in range(k):
				x.append('0')
				y.append('0')
			x.append('1')
			for _ in range(k, a):
				x.append('0')
				y.append('0')
			for _ in range(b - 1):
				x.append('1')
				y.append('1')
			x.reverse()
			y.reverse()
		else:
			for _ in range(b):
				x.append('1')
				y.append('1')
			for _ in range(a):
				x.append('0')
				y.append('0')
			y[-1] = '1'
			y[a + b - 2 - k + 1] = '0'
		print(''.join(x))
		print(''.join(y))
main()


import sys
input = sys.stdin.readline
(Z, O, k) = map(int, input().split())
if O == 1:
	if k == 0:
		print('Yes')
		print('1' + '0' * Z)
		print('1' + '0' * Z)
	else:
		print('No')
	sys.exit()
if Z == 0:
	if k == 0:
		print('Yes')
		print('1' * O)
		print('1' * O)
	else:
		print('No')
	sys.exit()
if k == 0:
	print('Yes')
	print('1' * O + '0' * Z)
	print('1' * O + '0' * Z)
	sys.exit()
MAX = Z + O - 2
if k > MAX:
	print('No')
	sys.exit()
if k <= Z:
	A = '1' * O + '0' * Z
	B = ['0'] * (Z + O)
	for i in range(O - 1):
		B[i] = '1'
	B[O + k - 1] = '1'
	print('Yes')
	print(A)
	print(''.join(B))
	sys.exit()
SA = MAX - k
A = '1' * O + '0' * Z
B = ['0'] * (Z + O)
B[0] = '1'
for i in range(1, 1 + SA):
	B[i] = '1'
B[-1] = '1'
for i in range(O - SA - 2):
	B[SA + i + 2] = '1'
print('Yes')
print(A)
print(''.join(B))


from sys import stdin
input = lambda : stdin.readline().strip()
lin = lambda : list(map(int, input().split()))
iin = lambda : int(input())
main = lambda : map(int, input().split())
from math import ceil, sqrt, factorial, log
from collections import deque
from bisect import bisect_left
mod = 998244353
mod = 1000000007

def gcd(a, b):
	(a, b) = (max(a, b), min(a, b))
	while a % b != 0:
		(a, b) = (b, a % b)
	return b

def moduloinverse(a):
	return pow(a, mod - 2, mod)

def solve(we):
	(a, b, k) = main()
	x = '1' * b + '0' * a
	x = int(x, 2)
	y = '1' + '0' + '1' * (b - 2) + '0' * (a - 1) + '1'
	y = int(y, 2)
	t = list(bin(x - y)).count('1')
	if b < 2:
		t = 0
	if k == 0:
		print('Yes')
		x = '1' * b + '0' * a
		print(x)
		print(x)
		return
	if a == 0:
		print('No')
		return
	if k > t:
		print('No')
		return
	print('Yes')
	x = '1' * b + '0' * a
	if b == 1:
		print(x)
		print(x)
	if k <= a:
		y = '1' * (b - 1) + '0' * a + '1'
		y = list(y)
		f = a
		for i in range(len(y) - 1, -1, -1):
			if k == f:
				break
			(y[i], y[i - 1]) = (y[i - 1], y[i])
			f -= 1
			if k == f:
				break
		print(x)
		for i in y:
			print(i, end='')
		print()
	else:
		y = '1' + '0' + '1' * (b - 2) + '0' * (a - 1) + '1'
		y = list(y)
		f = t
		for i in range(1, len(y)):
			if k == f:
				break
			(y[i], y[i + 1]) = (y[i + 1], y[i])
			f -= 1
			if k == f:
				break
		print(x)
		for i in y:
			print(i, end='')
		print()
qwe = 1
for _ in range(qwe):
	solve(_ + 1)


(a, b, k) = map(int, input().split())

def actual():
	a1 = a - 1
	b1 = b - 1
	ab = a + b
	if a == 0:
		if k != 0:
			return
		else:
			x = y = '1' * b
		return (x, y)
	elif k <= a:
		if b > 1:
			x = '1' * b + '0' * a
			y = '1' * b1 + '0' * k + '1' + '0' * (a - k)
			return (x, y)
		elif k == 0:
			y = x = '1' * b + '0' * a
			return (x, y)
		else:
			return
	elif k < ab - 1:
		if b > k:
			x = '1' * b + '0' * a
			y = '1' * (b - k) + '0' + '1' * k + '0' * a1
		elif b >= 2:
			z = '1' * (b - 2) + '0' * a1
			x = '11' + z[:k - 1] + '0' + z[k - 1:]
			y = '10' + z[:k - 1] + '1' + z[k - 1:]
		return (x, y)
ans = actual()
if ans:
	print('Yes')
	print(ans[0])
	print(ans[1])
else:
	print('No')


(a, b, k) = map(int, input().split())
if k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
	quit()
if k >= a + b - 1:
	print('No')
else:
	if b == 1 or a == 0:
		print('No')
		quit()
	first = '1' * b + '0' * a
	second = [c for c in first]
	take = min(a, k)
	k -= take
	second[b - 1 + take] = '1'
	second[b - k - 1] = '0'
	print('Yes')
	print(first)
	print(''.join(second))


import math
import sys
import collections
import bisect
import heapq
arr = list(map(int, sys.stdin.readline().strip().split()))
zeros = arr[0]
ones = arr[1]
k = arr[2]
pos = True
length = zeros + ones - 1
x = [1] + [0] * length
y = [1] + [0] * length
if k > length:
	print('No')
elif k == 0:
	print('Yes')
	st = '1' * ones + '0' * zeros
	print(st)
	print(st)
elif length == 1:
	print('No')
else:
	ix = 1
	iy = len(y) - 1
	onesx = 1
	onesy = 1
	done = False
	y[iy] = 1
	onesy += 1
	curr = 1
	iy -= 1
	while onesy != ones:
		if iy <= 1:
			print('No')
			pos = False
			break
		if curr == k:
			x[iy] = 1
			onesx += 1
			iy -= 1
			curr += 1
			done = True
		else:
			y[iy] = 1
			x[iy] = 1
			curr += 1
			onesy += 1
			onesx += 1
			iy -= 1
	if pos:
		if not done:
			while curr < k:
				if iy <= 1:
					print('No')
					pos = False
					break
				y[iy] = 0
				x[iy] = 0
				curr += 1
				iy -= 1
		if pos:
			if not done:
				x[iy] = 1
			print('Yes')
			for i in x:
				print(i, end='')
			print('')
			for i in y:
				print(i, end='')
			print('')


import io
import os
from collections import Counter, defaultdict, deque

def solve(A, B, K):
	N = A + B
	if N == K:
		return 'No'
	X = [0] * N
	Y = [0] * N
	Z = [0] * N
	Y[0] = 1
	if B - 1 - K >= 0:
		for i in range(B - 1):
			Y[N - 1 - i] = 1
		for i in range(B - 1 - K, B - 1):
			Z[N - 1 - i] = 1
	else:
		for i in range(B - 1):
			Y[N - 1 - i] = 1
		for i in range(K):
			Z[N - 1 - i] = 1
	carry = 0
	for i in reversed(range(N)):
		total = Y[i] + Z[i] + carry
		(carry, X[i]) = divmod(total, 2)
	if carry or X[0] != 1:
		return 'No'
	if sum(X) != B:
		return 'No'
	if DEBUG:
		assert sum(Y) == B
		assert sum(Z) == K
	X = ''.join(map(str, X))
	Y = ''.join(map(str, Y))
	if DEBUG:
		Z = ''.join(map(str, Z))
		print(Z)
		assert X >= Y
		assert int(X, 2) - int(Y, 2) == int(Z, 2)
	return 'Yes\n' + X + '\n' + Y
if False:
	for a in range(10):
		a = 1
		for b in range(1, 10):
			for k in range(a + b + 1):
				print()
				print(a, b, k)
				print(solve(a, b, k))
DEBUG = False
if DEBUG:
	import random
	_popcount = []
	for i in range(1 << 16):
		_popcount.append(bin(i).count('1'))
	MASK = (1 << 16) - 1
	random.seed(30)
	for _ in range(10000):
		A = random.randint(0, 8)
		B = random.randint(1, 8)
		K = random.randint(0, A + B)
		N = A + B
		cand = [mask1 for mask1 in range(1 << N) if 1 << N - 1 & mask1 and _popcount[mask1] == B]
		found = False
		for x in cand:
			for y in cand:
				z = x - y
				if z >= 0 and _popcount[z] == K:
					print(A, B, K)
					print('{0:32b}'.format(y))
					print('{0:32b}'.format(z))
					print('{0:32b}'.format(x))
					found = (x, y, z)
					break
			if found:
				break
		ans = solve(A, B, K)
		if found:
			print(A, B, K, found)
			assert ans.startswith('Yes')
		else:
			assert ans.startswith('No')
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = 1
for tc in range(1, TC + 1):
	(A, B, K) = [int(x) for x in input().split()]
	ans = solve(A, B, K)
	print(ans)


(a, b, k) = map(int, input().split())
(a, b) = (b, a)
if k == 0:
	print('Yes')
	print('1' * a + '0' * b)
	print('1' * a + '0' * b)
	exit()
if a <= 1 or b == 0:
	print('No')
	exit()
if a + b - 1 <= k:
	print('No')
	exit()
zero = b - 1
xl = [0]
yl = [1]
for i in range(k - 1):
	if zero > 0:
		xl.append(0)
		yl.append(0)
		zero -= 1
	else:
		xl.append(1)
		yl.append(1)
xl.append(1)
yl.append(0)
for i in range(a + b - k - 2):
	if zero > 0:
		xl.append(0)
		yl.append(0)
		zero -= 1
	else:
		xl.append(1)
		yl.append(1)
xl.append(1)
yl.append(1)
xl = [str(x) for x in xl]
yl = [str(y) for y in yl]
print('Yes')
print(''.join(xl[::-1]))
print(''.join(yl[::-1]))


import sys, math
import io, os
from collections import defaultdict as dd, deque, Counter

def data():
	return sys.stdin.buffer.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
mod = int(1000000000.0) + 7
(a, b, k) = mdata()
if k > max(a + b - 2, 0) or (b == 1 and k) or (a == 0 and k):
	out('NO')
else:
	out('YES')
	if k == 0:
		out('1' * b + '0' * a)
		out('1' * b + '0' * a)
	else:
		s1 = '0' * min(k, a)
		s2 = '1' + '0' * (min(k, a) - 1)
		(a, k) = (a - min(a, k), k - min(a, k))
		s1 += '1' * (b - 1) + '0' * a + '1'
		s2 += '1' * k + '0' + '1' * (b - k - 2) + '0' * a + '1'
		s1 = s1[::-1]
		s2 = s2[::-1]
		out(s1)
		out(s2)


import sys
input = sys.stdin.readline
l = input().split()
a = int(l[0])
b = int(l[1])
k = int(l[2])
if k == 0:
	print('Yes')
	print('1' * b, end='')
	print('0' * a)
	print('1' * b, end='')
	print('0' * a)
	quit()
if a == 0:
	if k == 0:
		print('Yes')
		print('1' * b)
		print('1' * b)
	else:
		print('No')
	quit()
if b == 1:
	if k == 0:
		print('Yes')
		print(1, end='')
		print('0' * a)
		print(1, end='')
		print('0' * a)
	else:
		print('No')
	quit()
if k > a + b - 2:
	print('No')
	quit()
print('Yes')
l1 = []
l2 = []
l1.append(1)
l2.append(1)
rem1 = b - 1
rem0 = a
l1.append(1)
l2.append(0)
rem1 -= 1
for i in range(k - 1):
	if rem1:
		l1.append(1)
		l2.append(1)
		rem1 -= 1
	else:
		l1.append(0)
		l2.append(0)
		rem0 -= 1
l1.append(0)
l2.append(1)
for i in range(a + b - (k + 2)):
	if rem1:
		l1.append(1)
		l2.append(1)
		rem1 -= 1
	else:
		l1.append(0)
		l2.append(0)
		rem0 -= 1
for i in l1:
	print(i, end='')
print()
for i in l2:
	print(i, end='')
print()


from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10 ** 5)
input = sys.stdin.readline
sqrt = math.sqrt

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

def LF():
	return list(map(float, input().split()))

def LI_():
	return list(map(lambda x: int(x) - 1, input().split()))

def II():
	return int(input())

def IF():
	return float(input())

def S():
	return input().rstrip()

def LS():
	return S().split()

def IR(n):
	return [II() for _ in range(n)]

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

def FR(n):
	return [IF() for _ in range(n)]

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

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

def SR(n):
	return [S() for _ in range(n)]

def LSR(n):
	return [LS() for _ in range(n)]
mod = 1000000007
inf = 10000000000.0

def solve():
	(a, b, k) = LI()
	if k == 0:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * b + '0' * a)
		return
	if a == 0:
		print('No')
		return
	if b == 1:
		print('No')
		return
	if k >= a + b - 1:
		print('No')
		return
	ans1 = ['1', '1'] + ['1'] * (b - 2) + ['0'] * a
	ans2 = ['1', '0'] + ['1'] * (b - 2) + ['0'] * (a - 1) + ['1']
	k = a + b - 2 - k
	j = b - 1
	f = 1
	for i in range(k):
		(ans1[j + 1], ans1[j]) = (ans1[j], ans1[j + 1])
		j += f
		if j == a + b - 1:
			j = b - 2
			f = -1
	print('Yes')
	print(''.join(ans1))
	print(''.join(ans2))
	return
solve()


__version__ = '2.1'
__date__ = '2021-03-10'
import sys

def solve(a, b, k):
	x = '1' * b + '0' * a
	if k <= b and k <= a:
		y = '1' * (b - 1) + '0' * k + '1' + '0' * (a - k)
	elif k > b:
		y = '10' + '1' * (b - 2) + '0' * (k - b + 1) + '1' + '0' * (a + b - k - 2)
	else:
		y = '1' * (b - k + min(a - 1, 1)) + '0' + '1' * (k - 2) + '0' * min(a - 1, 1) + '1' + '0' * (a - 1 - min(a - 1, 1)) + '1' * (1 - min(a - 1, 1))
	if int(x, 2) < int(y, 2):
		return False
	if y[0] == '0':
		return False
	return (x, y)

def main(argv=None):
	(a, b, k) = map(int, input().split())
	answer = solve(a, b, k)
	if answer:
		print('Yes')
		print(answer[0])
		print(answer[1])
	else:
		print('No')
	return 0
STATUS = main()
sys.exit(STATUS)


import time, math as mt, bisect as bs, sys
from sys import stdin, stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
from collections import defaultdict
pi = 3.141592653589793

def II():
	return int(stdin.readline())

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

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

def P(x):
	return stdout.write(str(x) + '\n')

def PI(x, y):
	return stdout.write(str(x) + ' ' + str(y) + '\n')

def lcm(a, b):
	return a * b // gcd(a, b)

def gcd(a, b):
	if a == 0:
		return b
	elif b == 0:
		return a
	if a > b:
		return gcd(a % b, b)
	else:
		return gcd(a, b % a)

def bfs(adj, v):
	visited = [False] * (v + 1)
	q = deque()
	while q:
		pass

def setBit(n):
	count = 0
	while n != 0:
		n = n & n - 1
		count += 1
	return count
mx = 10 ** 7
spf = [mx] * (mx + 1)

def readTree(n, e):
	adj = [set() for i in range(n + 1)]
	for i in range(e):
		(u1, u2) = IP()
		adj[u1].add(u2)
	return adj

def sieve():
	li = [True] * (10 ** 3 + 5)
	(li[0], li[1]) = (False, False)
	for i in range(2, len(li), 1):
		if li[i] == True:
			for j in range(i * i, len(li), i):
				li[j] = False
	(prime, cur) = ([0] * 200, 0)
	for i in range(10 ** 3 + 5):
		if li[i] == True:
			prime[cur] = i
			cur += 1
	return prime
spf = [1000000000.0 for i in range(10 ** 6 + 1)]

def SPF():
	mx = 10 ** 6 + 1
	spf[1] = 1
	for i in range(2, mx):
		if spf[i] == 1000000000.0:
			spf[i] = i
			for j in range(i * i, mx, i):
				if i < spf[j]:
					spf[j] = i
	return

def prime(n):
	prm = deque()
	d = {}
	while n != 1:
		prm.append(spf[n])
		n = n // spf[n]
	for ele in prm:
		d[ele] = d.get(ele, 0) + 1
	return d
mod = 998244353
inf = 10000000000000000

def solve():
	(a, b, k) = L()
	c = k + 1
	if k == 0:
		s = ['0' for i in range(a + b)]
		for i in range(b):
			s[i] = '1'
		ss = ''.join(s)
		print('Yes')
		print(ss)
		print(ss)
		return
	if a == 0:
		print('No')
		return
	if a + b - k - 1 > 0 and b > 1:
		print('Yes')
		s = ['0' for i in range(a + b)]
		t = ['0' for i in range(a + b)]
		s[a + b - k - 1] = '1'
		t[a + b - 1] = '1'
		(cnt, i) = (b - 1, 0)
		while cnt:
			if s[i] == '0':
				s[i] = '1'
				cnt -= 1
			i += 1
		(cnt, i) = (b - 1, 0)
		while cnt:
			if t[i] == '0' and i != a + b - k - 1:
				t[i] = '1'
				cnt -= 1
			i += 1
		ss = ''.join(s)
		tt = ''.join(t)
		print(ss)
		print(tt)
	else:
		print('No')
	return
t = 1
for i in range(t):
	solve()


(a, b, k) = map(int, input().split())
if a == 0 or b == 1:
	if k == 0:
		print('Yes')
		print('{}{}'.format('1' * b, '0' * a))
		print('{}{}'.format('1' * b, '0' * a))
	else:
		print('No')
elif k > a + b - 2:
	print('No')
elif k <= a:
	print('Yes')
	print('{}{}'.format('1' * b, '0' * a))
	print('{}{}{}{}'.format('1' * (b - 1), '0' * k, '1', '0' * (a - k)))
else:
	print('Yes')
	print('{}{}'.format('1' * b, '0' * a))
	print('{}{}{}{}{}'.format('1' * (b - (k - a) - 1), '0', '1' * (k - a), '0' * (a - 1), '1'))


import sys
input = sys.stdin.readline
(a, b, k) = map(int, input().split())
if b == 1:
	if k == 0:
		print('Yes')
		x = '1' + '0' * a
		y = '1' + '0' * a
		print(x)
		print(y)
	else:
		print('No')
elif k > a:
	if a == 0:
		print('No')
	elif k > a + b - 2:
		print('No')
	else:
		x = '11' + '0' * (a - 1) + '1' * (k - a) + '0' + '1' * (b - 2 - k + a)
		y = '1' + '0' * a + '1' * (b - 1)
		print('Yes')
		print(x)
		print(y)
else:
	x = '11' + '0' * k + '1' * (b - 2) + '0' * (a - k)
	y = '1' + '0' * k + '1' * (b - 1) + '0' * (a - k)
	print('Yes')
	print(x)
	print(y)


(a, b, k) = map(int, input().split())
if not k:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif a + b <= k + 1 or not a or b == 1:
	print('No')
else:
	s = '1' * (b - 1) + '0' * (a - 1)
	i = a + b - k - 1
	print('Yes')
	print(s[:i] + '1' + s[i:] + '0')
	print(s[:i] + '0' + s[i:] + '1')


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

def mapIn():
	return map(int, input().split())
(a, b, k) = mapIn()
if b == 0:
	if k > 0:
		print('NO')
	else:
		print('YES')
		s = '0' * a + '1' * b
		print(s)
		print(s)
elif b == 1:
	if k == 0:
		print('YES')
		s = '1' + '0' * a
		print(s)
		print(s)
	else:
		print('NO')
elif k > a + b - 2:
	print('NO')
elif a == 0:
	if k > 0:
		print('NO')
	else:
		print('YES')
		s = '1' * b
		print(s)
		print(s)
else:
	print('YES')
	n = a + b
	s = ''
	x = b
	for i in range(n):
		if x:
			x -= 1
			s += '1'
		else:
			s += '0'
	x = [0] * n
	x[0] = 1
	x[1] = 0
	y = b - 2
	for i in range(2, n - 1):
		if y:
			x[i] = 1
			y -= 1
	x[n - 1] = 1
	y = b - 2
	z = n - 2 - k
	if z > 0:
		i = 2
		if x[i] != 0:
			y -= 1
			z -= 1
			while y > 0 and z > 0:
				y -= 1
				z -= 1
				i += 1
			(x[1], x[i]) = (x[i], x[1])
		if z > 0:
			z -= 1
			i = n - 2
			while z:
				z -= 1
				i -= 1
			(x[i], x[n - 1]) = (x[n - 1], x[i])
	print(s)
	for i in range(n):
		print(x[i], end='')


import math
from collections import defaultdict, Counter
from itertools import permutations
from decimal import Decimal, localcontext
from collections import defaultdict
ii = lambda : int(input())
li = lambda : list(map(int, input().split()))

def main():
	(a, b, k) = li()
	if a == 0 or b == 1:
		if k == 0:
			x = '1' * b + '0' * a
			print('Yes')
			print(x)
			print(x)
		else:
			print('No')
	elif a >= k:
		print('Yes')
		aa = '1' * b + '0' * a
		bb = '1' * (b - 1) + '0' * k + '1' + '0' * (a - k)
		print(aa)
		print(bb)
	elif k <= a + b - 2:
		print('Yes')
		aa = '1' * b + '0' * a
		bb = '1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1'
		print(aa)
		print(bb)
	else:
		print('No')
import os, sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def random():
	rating = 100
	rating = rating * 100
	rating = rating * 100
	print(rating)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = [1]
	for p in range(2, n + 1):
		if prime[p]:
			l.append(p)
	return l

def fact(n):
	return 1 if n == 1 or n == 0 else n * fact(n - 1)

def prime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True


from sys import stdin, gettrace
if gettrace():

	def inputi():
		return input()
else:

	def input():
		return next(stdin)[:-1]

	def inputi():
		return stdin.buffer.readline()

def main():
	(a, b, k) = map(int, input().split())
	if k == 0:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * b + '0' * a)
		return
	if k > a + b - 2 or b < 2 or a == 0:
		print('No')
		return
	print('Yes')
	print('1' * b + '0' * a)
	if k < a:
		print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
	else:
		print('1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1')
main()


(a, b, k) = map(int, input().split())
if a >= k and b > 1:
	print('YES')
	for i in range(b - 1):
		print(1, end='')
	for i in range(a - k):
		print(0, end='')
	print(1, end='')
	for i in range(k):
		print(0, end='')
	print()
	for i in range(b - 1):
		print(1, end='')
	for i in range(a):
		print(0, end='')
	print(1, end='')
elif a + b - 2 >= k and a > 0 and (b > 1):
	print('YES')
	for i in range(b):
		print(1, end='')
	for i in range(a):
		print(0, end='')
	print()
	print(1, end='')
	for i in range(b - 2 - (k - a)):
		print(1, end='')
	print(0, end='')
	for i in range(k - a):
		print(1, end='')
	for i in range(a - 1):
		print(0, end='')
	print(1, end='')
elif k == 0:
	print('YES')
	for i in range(b):
		print(1, end='')
	for i in range(a):
		print(0, end='')
	print()
	for i in range(b):
		print(1, end='')
	for i in range(a):
		print(0, end='')
else:
	print('NO')


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
inp = lambda : list(map(int, sys.stdin.readline().rstrip('\r\n').split()))
mod = 10 ** 9 + 7
Mod = 998244353
INF = float('inf')
from bisect import *
tc = 1

def add(a, b):
	for i in range(-1, -len(b) - 1, -1):
		a[i] += b[i]
	for i in range(len(a) - 1, -1, -1):
		a[i - 1] += a[i] // 2
		a[i] = a[i] % 2
	return a
for _ in range(tc):
	(a, b, k) = inp()
	if k == 0:
		ans = '1' * b + '0' * a
		print('Yes')
		print(ans)
		print(ans)
	elif a == 0 or b == 1:
		print('No')
	else:
		c = [1] + [0] * a + [1] * (b - 1)
		e = c.copy()
		if k <= b - 1:
			d = [1] * k + [0] * (b - 1 - k)
			e = add(e, d)
			print('Yes')
			print(*e, sep='')
			print(*c, sep='')
		elif k < a + b - 1:
			d = [1] * k
			e = add(e, d)
			print('Yes')
			print(*e, sep='')
			print(*c, sep='')
		else:
			print('No')


import sys
input = sys.stdin.readline

def get_ret_1(a, b, k):
	if b == 1 and k == 0:
		x = y = '1' + '0' * a
		return 'Yes\n' + x + '\n' + y
	x = '1' * (b - 1) + '0' * (a + b - k - (b - 1) - 1) + '1' + '0' * k
	y = '1' * (b - 1) + '0' * (a + b - (b - 1) - 1) + '1'
	return 'Yes\n' + x + '\n' + y

def get_ret_2(a, b, k):
	x = '1' * b + '0' * a
	y = '1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1'
	return 'Yes\n' + x + '\n' + y

def main():
	(a, b, k) = map(int, input().split())
	if a == 0 and k != 0:
		print('No')
		return
	if b == 1 and k > 0:
		print('No')
		return
	if a >= k:
		print(get_ret_1(a, b, k))
	elif a + b - 2 >= k:
		print(get_ret_2(a, b, k))
	else:
		print('No')
main()


(a, b, k) = map(int, input().split())
if k == 0:
	x = [1]
	for i in range(a + b - 1):
		if a:
			x.append(0)
			a -= 1
		else:
			x.append(1)
	print('Yes')
	print(''.join(map(str, x)))
	print(''.join(map(str, x)))
elif k >= a + b - 1:
	print('No')
elif b == 1 or a == 0:
	print('No')
else:
	print('Yes')
	x = [1, 1]
	y = [1, 0]
	b -= 2
	a -= 1
	for i in range(k - 1):
		if a > 0:
			x.append(0)
			y.append(0)
			a -= 1
		else:
			x.append(1)
			y.append(1)
			b -= 1
	x.append(0)
	y.append(1)
	while a > 0:
		x.append(0)
		y.append(0)
		a -= 1
	while b > 0:
		x.append(1)
		y.append(1)
		b -= 1
	print(''.join(map(str, x)))
	print(''.join(map(str, y)))


import sys
input = sys.stdin.readline
(a, b, k) = map(int, input().split())
if a == 0 or b == 1:
	if k == 0:
		print('YES')
		for i in range(b):
			print(1, end='')
		for i in range(a):
			print(0, end='')
		print()
		for i in range(b):
			print(1, end='')
		for i in range(a):
			print(0, end='')
		print()
	else:
		print('NO')
elif k > b - 1 + a - 1:
	print('NO')
else:
	print('YES')
	for i in range(b):
		print(1, end='')
	for i in range(a):
		print(0, end='')
	print()
	if k <= a:
		for i in range(b - 1):
			print(1, end='')
		for i in range(k):
			print(0, end='')
		print(1, end='')
		for i in range(a - k):
			print(0, end='')
		print()
	else:
		for i in range(a + b - k - 1):
			print(1, end='')
		print(0, end='')
		for i in range(k - a):
			print(1, end='')
		for i in range(a - 1):
			print(0, end='')
		print(1)


from sys import stdin, exit
from bisect import bisect_left as bl, bisect_right as br
from itertools import accumulate
yes = lambda : print('Yes')
no = lambda : print('No')
input = lambda : stdin.readline()[:-1]
intput = lambda : int(input())
sinput = lambda : input().split()
intsput = lambda : map(int, sinput())

def dprint(*args, **kwargs):
	if debugging:
		print(*args, **kwargs)
debugging = 1
(zeros, ones, k) = intsput()
ones -= 1
if zeros == 0:
	if k == 0:
		yes()
		print('1' * (ones + 1))
		print('1' * (ones + 1))
	else:
		no()
	exit()
if ones == 0:
	if k == 0:
		yes()
		print('1' + '0' * zeros)
		print('1' + '0' * zeros)
	else:
		no()
	exit()
x = [1]
y = [1]
digits = zeros + ones
possible = digits - 1
if k > possible:
	no()
	exit()
yes()
reduce = possible - k
max_reduce_by_packing = max(ones - 1, 0)
if max_reduce_by_packing >= reduce:
	packed = reduce
	for _ in range(packed):
		x.append(1)
		y.append(1)
	x.append(1)
	y.append(0)
	rem = ones - packed - 1
	for _ in range(rem):
		x.append(1)
		y.append(1)
	for _ in range(zeros - 1):
		x.append(0)
		y.append(0)
	x.append(0)
	y.append(1)
else:
	reduce_by_packing = max_reduce_by_packing
	for _ in range(reduce_by_packing):
		x.append(1)
		y.append(1)
	shift = reduce - reduce_by_packing
	x += [0] * shift + [1]
	x += (digits + 1 - len(x)) * [0]
	y += (digits - len(y)) * [0]
	y += [1]
print(''.join(map(str, x)))
print(''.join(map(str, y)))


def getints():
	return map(int, input().split())
(z, o, k) = getints()
if k == 0:
	print('Yes')
	s = '1' * o + '0' * z
	print(s)
	print(s)
elif o == 1 or z == 0:
	print('No')
elif k <= z + o - 2:
	print('Yes')
	if k >= o:
		mx = z + o - 2
		print('1' + '0' * (mx - k) + '1' + '0' * (z - 1 - (mx - k)) + '1' * (o - 2) + '0')
	else:
		print('1' + '0' * (z - 1) + '1' * k + '0' + '1' * (o - k - 1))
	print('1' + '0' * z + '1' * (o - 1))
else:
	print('No')


from sys import stdin, stdout
nmbr = lambda : int(stdin.readline())
lst = lambda : list(map(int, stdin.readline().split()))
for _ in range(1):
	(z, o, k) = lst()
	if o == 1 and k != 0 or (z == 0 and k != 0):
		print('No')
		continue
	if k > z:
		sel = o + z - k - 1
		if sel <= 0:
			print('No')
		else:
			s1 = [1] * o + [0] * z
			s2 = s1.copy()
			(s2[sel], s2[-1]) = (s2[-1], s2[sel])
			print('Yes')
			for ch in s1:
				stdout.write(str(ch))
			print()
			for ch in s2:
				stdout.write(str(ch))
	else:
		s1 = [1] * o + [0] * z
		s2 = [1] * (o - 1) + [0] * (1 + z)
		s2[k + o - 1] = 1
		print('Yes')
		for ch in s1:
			stdout.write(str(ch))
		print()
		for ch in s2:
			stdout.write(str(ch))


(a, b, k) = map(int, input().split())
if k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
	exit(0)
if a == 0 or b == 0:
	print('No')
	exit(0)
a -= 1
b -= 1
if b == 0:
	print('No')
	exit(0)
s = '1' * b + '0' * a
b -= 1
k -= 1
if k > a + b:
	print('No')
	exit(0)
print('Yes')
print(s[:len(s) - k] + '1' + s[len(s) - k:] + '0')
print(s[:len(s) - k] + '0' + s[len(s) - k:] + '1')


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
(z1, o1, o2) = map(int, input().split())
z2 = z1 + o1 - o2
f = '1' * o1 + '0' * z1
ans = 'YES'
if not z1 or o1 == 1:
	if o2:
		ans = 'NO'
	else:
		s = '1' * o1 + '0' * z1
elif o2 <= z1:
	s = '1' * (o1 - 1) + '0' * o2 + '1' + '0' * (z1 - o2)
elif o2 < o1 + z1 - 1:
	s = '1' * (z1 + o1 - o2 - 1) + '0' + '1' * (o2 - z1) + '0' * (z1 - 1) + '1'
else:
	ans = 'NO'
if ans == 'NO':
	print(ans)
else:
	print(ans)
	print(f)
	print(s)


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class SegmentTree:

	def __init__(self, data, default=-10 ** 6, func=lambda a, b: max(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree1:

	def __init__(self, data, default=10 ** 6, func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)
MOD = 10 ** 9 + 7

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod = 10 ** 9 + 7
omod = 998244353
prime = [True for i in range(200001)]
pp = [0] * 200001

def SieveOfEratosthenes(n=200000):
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
(a, b, k) = map(int, input().split())
if k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
	exit()
if b == 1 or a == 0 or k > a + b - 2:
	print('No')
	exit()
print('Yes')
b -= 2
a -= 1
b1 = min(k - 1, b)
a1 = k - 1 - b1
print('11' + '1' * b1 + '0' * a1 + '0' + '1' * (b - b1) + '0' * (a - a1))
print('10' + '1' * b1 + '0' * a1 + '1' + '1' * (b - b1) + '0' * (a - a1))


from sys import stdin, stdout, setrecursionlimit
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log, log2
from random import seed, randint
from datetime import datetime
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
from collections import defaultdict as dd
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

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

def def_value():
	return 0

def def_inf():
	return inf
(a, b, k) = mp()
if k == 0:
	print('YES')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif a == 0 or b == 1 or k > a + b - 2:
	print('NO')
elif a >= k:
	print('YES')
	print('1' * b + '0' * a)
	print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
else:
	print('YES')
	print('1' * b + '0' * a)
	x = k - a
	print('1' * (b - 1 - x) + '0' + '1' * x + '0' * (a - 1) + '1')


from sys import stdin
input = stdin.readline

def main():
	(a, b, k) = map(int, input().split())
	if b == 1 or a == 0:
		if k != 0:
			print('No')
			return
		else:
			x = ['1'] * b + ['0'] * a
			y = x.copy()
	elif k > a + b - 2:
		print('No')
		return
	elif k <= a:
		x = ['1'] * (b - 1) + ['0'] * (a - k)
		y = x.copy()
		x = x + ['1'] + ['0'] * k
		y = y + ['0'] * k + ['1']
	else:
		x = ['1'] * b + ['0'] * a
		y = x.copy()
		y[-k - 1] = '0'
		y[-1] = '1'
	x = ''.join(x)
	y = ''.join(y)
	print('Yes')
	print(x)
	print(y)
main()


x = input().split()
a = int(x[0])
b = int(x[1])
k = int(x[2])
if k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif k < b and a > 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * (b - k) + '0' + '1' * k + '0' * (a - 1))
elif k < a + b and b > 1 and (a > k - b + 1) and (a > 0):
	print('Yes')
	print('11' + '0' * (k - b + 1) + '1' * (b - 2) + '0' * (a + b - k - 1))
	print('10' + '0' * (k - b + 1) + '1' * (b - 1) + '0' * (a + b - k - 2))
else:
	print('No')


(a, b, k) = list(map(int, input().split()))
if k == 0:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * b + '0' * a)
elif a + b - 1 <= k:
	print('No')
elif a >= k:
	if b == 1 and k > 0:
		print('No')
	elif a == 0 and k == 0:
		print('Yes')
		print('1' * b)
		print('1' * b)
	else:
		print('Yes')
		print('1' * b + '0' * a)
		print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
elif a == 0 and k > 0:
	print('No')
else:
	c = k - a
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * (b - c - 1) + '0' + '1' * c + '0' * (a - 1) + '1')


def Solve(a, b, k):
	if a + b - 2 < k and k != 0 or (b == 1 and k > 0) or ((b == 0 or a == 0) and k > 0) or (b == 0):
		print('No')
		return
	print('Yes')
	x = [0] * (a + b)
	y = [0] * (a + b)
	m = a + b - 1
	if k != 0:
		x[0] = y[0] = 1
		b -= 1
		n = 1 + a + b - k - 1
		for i in range(1, n):
			if a > 1:
				x[i] = y[i] = 0
				a -= 1
			else:
				x[i] = y[i] = 1
				b -= 1
		x[n] = y[m] = 1
		x[m] = y[n] = 0
		b -= 1
		a -= 1
		n += 1
		for i in range(n, m):
			if a > 0:
				x[i] = y[i] = 0
				a -= 1
			else:
				x[i] = y[i] = 1
				b -= 1
	else:
		for i in range(a + b):
			if b > 0:
				x[i] = y[i] = 1
				b -= 1
			else:
				x[i] = y[i] = 0
				a -= 1
	for bit in x:
		print(int(bit), end='')
	print()
	for bit in y:
		print(int(bit), end='')
(a, b, k) = map(int, input().split())
Solve(a, b, k)


import os
import sys
from io import BytesIO, IOBase
import heapq as h
import bisect
import math as mt
from types import GeneratorType
BUFSIZE = 8192

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
import sys
from math import ceil, log2
INT_MAX = sys.maxsize
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import collections as col
import math, string

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def minVal(x, y):
	return x if x < y else y

def getMid(s, e):
	return s + (e - s) // 2

def RMQUtil(st, ss, se, qs, qe, index):
	if qs <= ss and qe >= se:
		return st[index]
	if se < qs or ss > qe:
		return INT_MAX
	mid = getMid(ss, se)
	return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1), RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2))

def RMQ(st, n, qs, qe):
	if qs < 0 or qe > n - 1 or qs > qe:
		print('Invalid Input')
		return -1
	return RMQUtil(st, 0, n - 1, qs, qe, 0)

def constructSTUtil(arr, ss, se, st, si):
	if ss == se:
		st[si] = arr[ss]
		return arr[ss]
	mid = getMid(ss, se)
	st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1), constructSTUtil(arr, mid + 1, se, st, si * 2 + 2))
	return st[si]

def constructST(arr, n):
	x = int(ceil(log2(n)))
	max_size = 2 * int(2 ** x) - 1
	st = [0] * max_size
	constructSTUtil(arr, 0, n - 1, st, 0)
	return st
MOD = 10 ** 9 + 7
mod = 10 ** 9 + 7
p = 10 ** 9 + 7

def ncr_util():
	inv[0] = inv[1] = 1
	fact[0] = fact[1] = 1
	for i in range(2, 300001):
		inv[i] = inv[i % p] * (p - p // i) % p
	for i in range(1, 300001):
		inv[i] = inv[i - 1] * inv[i] % p
		fact[i] = fact[i - 1] * i % p

def z_array(s1):
	n = len(s1)
	z = [0] * n
	(l, r, k) = (0, 0, 0)
	for i in range(1, n):
		if i > r:
			(l, r) = (i, i)
			while r < n and s1[r - l] == s1[r]:
				r += 1
			z[i] = r - l
			r -= 1
		else:
			k = i - l
			if z[k] < r - i + 1:
				z[i] = z[k]
			else:
				l = i
				while r < n and s1[r - l] == s1[r]:
					r += 1
				z[i] = r - l
				r -= 1
	return z

def fs(x):
	if x < 2:
		return 0
	return x * (x - 1) // 2
t = 1

def solve(a, b, k):
	l1 = []
	l2 = []
	if k == 0:
		print('YES')
		for i in range(b):
			l1.append(1)
			l2.append(1)
		for i in range(a):
			l1.append(0)
			l2.append(0)
		print(*l1, sep='')
		print(*l2, sep='')
	elif b >= 2 and k <= a + b - 2 and (a > 0):
		print('YES')
		for i in range(b):
			l1.append(1)
		for i in range(a):
			l1.append(0)
		print(*l1, sep='')
		if k < a:
			print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
		else:
			print('1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1')
	else:
		print('NO')
for _ in range(t):
	(a, b, k) = map(int, input().split())
	solve(a, b, k)


import itertools

def main():
	(a, b, k) = map(int, input().split())
	maxi = 2 ** (a + b) - 2 ** a - 2
	mini = 2 ** (a + b - 1) + 2 ** (b - 1) - 1
	mini_k_ones = 2 ** k - 1
	if b == 1 or a == 0:
		if k == 0:
			print('Yes')
			print('1' * b + '0' * a)
			print('1' * b + '0' * a)
		else:
			print('No')
	elif k > a:
		if k >= a + b - 1:
			print('No')
		else:
			v = k - a
			x = '1' * (b - v) + (a - 1) * '0' + v * '1' + '0'
			y = '1' * (b - v - 1) + a * '0' + (v + 1) * '1'
			print('Yes')
			print(x)
			print(y)
	else:
		print('Yes')
		x = b * '1' + a * '0'
		y = '1' * (b - 1) + k * '0' + '1' + (a - k) * '0'
		print(x)
		print(y)
main()

def brute_force(a, b, k):
	for p in itertools.combinations(range(a + b - 1), b):
		for p2 in itertools.combinations(range(a + b - 1), b):
			n = sum((2 ** c for c in p)) + 2 ** (b - 1)
			n2 = sum((2 ** c for c in p)) + 2 ** (b - 1)
			print(str(n).count('1'))


(a, b, k) = map(int, input().split())
if a == 0:
	if k == 0:
		s = b * '1'
		print('Yes')
		print(s)
		print(s)
	else:
		print('No')
	exit()
if b == 1:
	if k == 0:
		s = '1' + a * '0'
		print('Yes')
		print(s)
		print(s)
	else:
		print('No')
	exit()
if k > a + b - 2:
	print('No')
	exit()
s = '1' * b + '0' * a
if k <= a:
	t = '1' * (b - 1) + '0' * k + '1' + '0' * (a - k)
	print('Yes')
	print(s)
	print(t)
	exit()
left = k - a
t = (b - left - 1) * '1' + '0' + left * '1' + (a - 1) * '0' + '1'
print('Yes')
print(s)
print(t)


(a, b, k) = map(int, input().split())
if a == k == 0 and b == 1:
	print('Yes')
	print(1)
	print(1)
elif k > a + b - 2 or (b == 1 and k > 0) or (a == 0 and k > 0):
	print('No')
elif k == 0:
	sa = '1'
	sb = '1'
	b -= 1
	while b:
		sa += '1'
		sb += '1'
		b -= 1
	while a:
		sa += '0'
		sb += '0'
		a -= 1
	print('Yes')
	print(sa)
	print(sb)
else:
	sa = '1'
	sb = '1'
	b -= 1
	sa += '1'
	sb += '0'
	k -= 1
	b -= 1
	a -= 1
	ss = '0' * a + '1' * b
	sa += ss[:k] + '0' + ss[k:]
	sb += ss[:k] + '1' + ss[k:]
	print('Yes')
	print(sa)
	print(sb)


(a, b, k) = map(int, input().split())
if b == 1:
	if k == 0:
		print('Yes')
		print('1' + '0' * a)
		print('1' + '0' * a)
	else:
		print('No')
elif k <= a:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * (b - 1) + '0' * k + '1' + '0' * (a - k))
elif a >= 1 and a + b >= k + 2:
	print('Yes')
	print('1' * b + '0' * a)
	print('1' * (a + b - k - 1) + '0' + '1' * (k - a) + '0' * (a - 1) + '1')
else:
	print('No')