You are given two strings $s$ and $t$ both of length $2$ and both consisting only of characters 'a', 'b' and 'c'.

Possible examples of strings $s$ and $t$: "ab", "ca", "bb".

You have to find a string $res$ consisting of $3n$ characters, $n$ characters should be 'a', $n$ characters should be 'b' and $n$ characters should be 'c' and $s$ and $t$ should not occur in $res$ as substrings.

A substring of a string is a contiguous subsequence of that string. So, the strings "ab", "ac" and "cc" are substrings of the string "abacc", but the strings "bc", "aa" and "cb" are not substrings of the string "abacc".

If there are multiple answers, you can print any of them.


-----Input-----

The first line of the input contains one integer $n$ ($1 \le n \le 10^5$) — the number of characters 'a', 'b' and 'c' in the resulting string.

The second line of the input contains one string $s$ of length $2$ consisting of characters 'a', 'b' and 'c'.

The third line of the input contains one string $t$ of length $2$ consisting of characters 'a', 'b' and 'c'.


-----Output-----

If it is impossible to find the suitable string, print "NO" on the first line. 

Otherwise print "YES" on the first line and string $res$ on the second line. $res$ should consist of $3n$ characters, $n$ characters should be 'a', $n$ characters should be 'b' and $n$ characters should be 'c' and $s$ and $t$ should not occur in $res$ as substrings.

If there are multiple answers, you can print any of them.


-----Examples-----
Input
2
ab
bc

Output
YES
acbbac

Input
3
aa
bc

Output
YES
cacbacbab

Input
1
cb
ac

Output
YES
abc

Difficulty: HARD

Solutions:
def main():
	from itertools import permutations as pm
	n = int(input())
	s = 'abc'
	a = list(pm(s))
	a = [''.join(i) for i in a]
	b = [i * n for i in a]
	for i in a:
		b.append(i[0] * n + i[1] * n + i[2] * n)
	z1 = input()
	z2 = input()
	for i in b:
		if z1 not in i:
			if z2 not in i:
				print('YES')
				print(i)
				return
	print('NO')
	return
main()


n = int(input())
a = ['abc' * n, 'acb' * n, 'bac' * n, 'bca' * n, 'cab' * n, 'cba' * n, 'a' * n + 'b' * n + 'c' * n, 'a' * n + 'c' * n + 'b' * n, 'b' * n + 'a' * n + 'c' * n, 'b' * n + 'c' * n + 'a' * n, 'c' * n + 'a' * n + 'b' * n, 'c' * n + 'b' * n + 'a' * n]
(s, t) = (input(), input())
print('YES')
for e in a:
	if s not in e and t not in e:
		print(e)
		break


n = int(input())
s = input()
t = input()
mylist = []
mylist.append('abc' * n)
mylist.append('a' * n + 'b' * n + 'c' * n)
mylist.append('acb' * n)
mylist.append('a' * n + 'c' * n + 'b' * n)
mylist.append('bac' * n)
mylist.append('b' * n + 'a' * n + 'c' * n)
mylist.append('bca' * n)
mylist.append('b' * n + 'c' * n + 'a' * n)
mylist.append('cab' * n)
mylist.append('c' * n + 'a' * n + 'b' * n)
mylist.append('cba' * n)
mylist.append('c' * n + 'b' * n + 'a' * n)
flag = False
for i in mylist:
	if s not in i and t not in i:
		print('YES')
		print(i)
		flag = True
		break
if not flag:
	print('No')


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter
from itertools import combinations
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192
from sys import stderr

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))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

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

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

def fsep():
	return map(float, inp().split())

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def pow(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

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

def prefix_sum(ar):
	return list(accumulate(ar))

def suffix_sum(ar):
	return list(accumulate(ar[::-1]))[::-1]

def N():
	return int(inp())
from collections import defaultdict

def numberOfSetBits(i):
	i = i - (i >> 1 & 1431655765)
	i = (i & 858993459) + (i >> 2 & 858993459)
	return ((i + (i >> 4) & 252645135) * 16843009 & 4294967295) >> 24

def solve():
	n = N()
	s = inp()
	t = inp()
	potentials = []
	per = permutate('abc', 3)
	for i in per:
		(a, b, c) = i
		temp1 = (a + b + c) * n
		temp2 = a * n + b * n + c * n
		potentials.append(temp1)
		potentials.append(temp2)
	for i in potentials:
		if s not in i and t not in i:
			print('YES')
			print(i)
			return
	print('NO')
solve()


n = int(input())
s = input()
t = input()
c = 'abc'
k = 0
a1 = 0
a2 = 0
ans = ''
for i in c:
	for j in c:
		for k in c:
			if i != j and i != k and (j != k):
				a1 = 0
				a2 = 0
				st1 = (i + j + k) * n
				st2 = i * n + j * n + k * n
				for p in range(3 * n - 1):
					if st1[p:p + 2] == s or st1[p:p + 2] == t:
						a1 = 1
					if st2[p:p + 2] == s or st2[p:p + 2] == t:
						a2 = 1
					if a1 == 1 and a2 == 1:
						break
				if a1 != 1:
					ans = st1
					break
				elif a2 != 1:
					ans = st2
					break
		if ans != '':
			break
	if ans != '':
		break
print('YES')
print(ans)


n = int(input())
s = input()
t = input()
us = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
flag = 0
for u in us:
	if s in u or t in u:
		continue
	if n > 1 and (s in u[2] + u[0] or t in u[2] + u[0]):
		continue
	flag = 1
	print('YES')
	print(u * n)
	exit()
if not flag:
	for u in us:
		if s in u or t in u:
			continue
		print('YES')
		print(u[0] * n + u[1] * n + u[2] * n)
		exit()


import sys
sys.setrecursionlimit(10 ** 5 + 1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
from itertools import permutations
alls = 'abc'
permlist = [''.join(perms) for perms in list(permutations(alls))]
answer = []
(n, s, t) = (RI(), RW(), RW())
for i in permlist:
	answer.append(i * n)
	curr = ''
	curr = i[0] * n
	curr += i[1] * n
	curr += i[2] * n
	answer.append(curr)
valid = 'NO'
for i in answer:
	if s in i or t in i:
		continue
	else:
		valid = 'YES'
		break
print(valid)
if valid == 'YES':
	print(i)


n = int(input())
s = input()
t = input()
arr = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
print('YES')
flag = 0
for i in range(6):
	arr[i] = arr[i] * n
	if s not in arr[i] and t not in arr[i]:
		print(arr[i])
		flag = 1
		break
if flag == 0:
	s1 = 'a' * n
	s2 = 'b' * n
	s3 = 'c' * n
	arr = [s1 + s2 + s3, s1 + s3 + s2, s2 + s1 + s3, s2 + s3 + s1, s3 + s1 + s2, s3 + s2 + s1]
	for x in arr:
		if s not in x and t not in x:
			print(x)
			break


print('YES\n' + [[q for q in ['abc' * n, 'acb' * n, 'bac' * n, 'bca' * n, 'cab' * n, 'cba' * n, 'a' * n + 'b' * n + 'c' * n, 'a' * n + 'c' * n + 'b' * n, 'b' * n + 'a' * n + 'c' * n, 'b' * n + 'c' * n + 'a' * n, 'c' * n + 'a' * n + 'b' * n, 'c' * n + 'b' * n + 'a' * n] if s not in q and t not in q][0] for (n, s, t) in [[int(input()), input(), input()]]][0])


from itertools import permutations
import sys
n = int(input())
s = input()
t = input()
for p in permutations('abc', 3):
	a = n * ''.join(p)
	b = ''.join((n * c for c in p))
	if s not in a and t not in a:
		print('YES')
		print(a)
		sys.exit()
	elif s not in b and t not in b:
		print('YES')
		print(b)
		sys.exit()
print('NO')


n = int(input())
a = input()
b = input()
arr = list()
arr.append('abc' * n)
arr.append('acb' * n)
arr.append('a' * n + 'b' * n + 'c' * n)
arr.append('a' * n + 'c' * n + 'b' * n)
arr.append('b' * n + 'a' * n + 'c' * n)
arr.append('b' * n + 'c' * n + 'a' * n)
arr.append('c' * n + 'a' * n + 'b' * n)
arr.append('c' * n + 'b' * n + 'a' * n)
flag = False
for s in arr:
	if s.find(a) == -1 and s.find(b) == -1:
		print('YES')
		print(s)
		flag = True
		break
if not flag:
	print('NO')


from sys import stdin
inp = stdin.readline
n = int(inp().strip())
(s, t) = (inp().strip(), inp().strip())
abc = ['a', 'b', 'c']
for i in abc:
	for j in abc:
		if i != j:
			for k in abc:
				if i != j and j != k and (i != k):
					ans = ''.join([i, j, k])
					ans = ans * n
					if s not in ans and t not in ans:
						print('YES')
						print(ans)
						exit()
					ans2 = ''.join([i] * n + [j] * n + [k] * n)
					if s not in ans2 and t not in ans2:
						print('YES')
						print(ans2)
						exit()
print('NO')
exit()


n = int(input())
s = input()
t = input()
perms = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
ans = []
for cycle in perms:
	ans.append(n * cycle)
	ans.append(n * cycle[0] + n * cycle[1] + n * cycle[2])
for a in ans:
	for i in range(3 * n - 1):
		if a[i:i + 2] == s or a[i:i + 2] == t:
			break
	else:
		print('YES')
		print(a)
		break


n = int(input())
s = input()
t = input()
a = []
from itertools import permutations
permList = permutations('abc')
for perm in list(permList):
	a.append(''.join(perm) * n)
	a.append(perm[0] * n + perm[1] * n + perm[2] * n)
for i in a:
	if s not in i and t not in i:
		print('YES')
		print(i)
		exit()
print('NO')


import sys

def main():
	n = int(sys.stdin.readline().strip())
	s1 = sys.stdin.readline().strip()
	s2 = sys.stdin.readline().strip()
	for c1 in 'abc':
		for c2 in 'abc':
			for c3 in 'abc':
				if len(set(c1 + c2 + c3)) != 3:
					continue
				ss = (c1 + c2 + c3) * n
				if s1 in ss or s2 in ss:
					continue
				print('YES')
				print(ss)
				return
	for c1 in 'abc':
		for c2 in 'abc':
			for c3 in 'abc':
				if len(set(c1 + c2 + c3)) != 3:
					continue
				ss = c1 * n + c2 * n + c3 * n
				if s1 in ss or s2 in ss:
					continue
				print('YES')
				print(ss)
				return
	print('NO')
main()


def good(s, t, r):
	for i in range(len(s) - 1):
		pa = s[i:i + 2]
		if pa == t or pa == r:
			return False
	return True
n = int(input())
s = input()
t = input()
l = ['abc' * n, 'acb' * n, 'bac' * n, 'bca' * n, 'cab' * n, 'cba' * n]
l.append('a' * n + 'b' * n + 'c' * n)
l.append('a' * n + 'c' * n + 'b' * n)
l.append('b' * n + 'a' * n + 'c' * n)
l.append('b' * n + 'c' * n + 'a' * n)
l.append('c' * n + 'a' * n + 'b' * n)
l.append('c' * n + 'b' * n + 'a' * n)
print('YES')
for x in l:
	if good(x, s, t):
		print(x)
		exit()


import math
import sys
from collections import defaultdict
rt = lambda : map(int, input().split())
ri = lambda : int(input())
rl = lambda : list(map(int, input().split()))

def main():
	n = ri()
	s = input()
	t = input()
	trios = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
	if n == 1:
		found = None
		for trio in trios:
			if s not in trio and t not in trio:
				found = trio
				break
		if found:
			print('YES')
			print(found)
		else:
			print('NO')
	else:
		found = None
		for t1 in trios:
			x = t1 + t1
			if s not in x and t not in x:
				found = t1
				break
		if found:
			print('YES')
			print(found * n)
		else:
			rem = {'a': 'bc', 'b': 'ac', 'c': 'ab'}
			if s[0] == t[0]:
				print('YES')
				f = s[0]
				print(f'{rem[f][0] * n}{rem[f][1] * n}{f * n}')
			elif s[1] == t[1]:
				print('YES')
				last = s[1]
				print(f'{last * n}{rem[last][0] * n}{rem[last][1] * n}')
			elif s[0] == t[1] and s[1] == t[0]:
				x1 = s[0]
				x2 = s[1]
				if x1 != 'a' and x2 != 'a':
					x3 = 'a'
				if x1 != 'b' and x2 != 'b':
					x3 = 'b'
				if x1 != 'c' and x2 != 'c':
					x3 = 'c'
				print('YES')
				print(f'{x1 * n}{x3 * n}{x2 * n}')
			else:
				print('NO')
main()


from itertools import permutations
n = int(input())
s = input()
t = input()
p = permutations('abc')
v = []
for i in p:
	v.append(''.join((k for k in i)) * n)
	v.append(''.join((k * n for k in i)))
for word in v:
	if word.find(s) == -1 and word.find(t) == -1:
		print('YES')
		print(word)
		break
else:
	print('NO')


n = int(input())
s1 = input()
s2 = input()
flag = 0
l1 = []
l = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
for i in l:
	l1.append(i * n)
	l1.append(i[0] * n + i[1] * n + i[2] * n)
for i in l1:
	if s1 not in i and s2 not in i:
		print('YES')
		print(i)
		flag = 1
		break
if flag == 0:
	print('NO')