Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.

GukiZ has strings *a*, *b*, and *c*. He wants to obtain string *k* by swapping some letters in *a*, so that *k* should contain as many non-overlapping substrings equal either to *b* or *c* as possible. Substring of string *x* is a string formed by consecutive segment of characters from *x*. Two substrings of string *x* overlap if there is position *i* in string *x* occupied by both of them.

GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings *k*?
The first line contains string *a*, the second line contains string *b*, and the third line contains string *c* (1 ≤ |*a*|, |*b*|, |*c*| ≤ 10<sup class="upper-index">5</sup>, where |*s*| denotes the length of string *s*).

All three strings consist only of lowercase English letters. 

It is possible that *b* and *c* coincide.
a = input()
b = input()
c = input()
if len(b) > len(c):
    b, c = c, b

bucketA = [0]*26
bucketB = [0]*26
bucketC = [0]*26

for i in a: bucketA[ord(i)-ord('a')] += 1
for i in b: bucketB[ord(i)-ord('a')] += 1
for i in c: bucketC[ord(i)-ord('a')] += 1

ans = ''
INF = 10**5+1
cntB, cntC = INF, INF
for i in range(26):
    if bucketB[i] > 0:
        cntB = min(cntB, bucketA[i]//bucketB[i])
    if bucketC[i] > 0:
        cntC = min(cntC, bucketA[i]//bucketC[i])

if cntB > cntC:
    ans += (b * cntB)
    for i, bb in enumerate(bucketB):
        bucketA[i] -= bb * cntB
        assert bucketA[i] >= 0

    cntC = 0
    for i in range(26):
        if bucketC[i] > 0:
            cntC = min(cntC, bucketA[i]//bucketC[i])

    ans += (c * cntC)    
    for i, bc in enumerate(bucketC):
        bucketA[i] -= bc * cntC
        assert bucketA[i] >= 0
else:
    ans += (c * cntC)    
    for i, bc in enumerate(bucketC):
        bucketA[i] -= bc * cntC
        assert bucketA[i] >= 0

    cntB = 0
    for i in range(26):
        if bucketB[i] > 0:
            cntB = min(cntB, bucketA[i]//bucketB[i])

    ans += (b * cntB)
    for i, bb in enumerate(bucketB):
        bucketA[i] -= bb * cntB
        assert bucketA[i] >= 0

for i, ba in enumerate(bucketA):
    ans += (chr(ord('a')+i) * ba)
print(ans)
    

