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.
from collections import defaultdict


def find_max_possible_substring(a, a_char_counts, char_counts):
    max_count_of_sub = len(a)
    for char, count in char_counts.items():
        max_count_of_sub = min(max_count_of_sub, a_char_counts[char] // char_counts[char])

    return max_count_of_sub


def get_result(a_char_counts, first, max_count_of_first, first_char_counts, second_char_counts):
    result = ""
    result += first * max_count_of_first

    for char, count in first_char_counts.items():
        a_char_counts[char] -= count * max_count_of_first

    remaining_count_of_c = find_max_possible_substring(a, a_char_counts, second_char_counts)

    if remaining_count_of_c:
        result += c * remaining_count_of_c
        for char, count in second_char_counts.items():
            a_char_counts[char] -= count * remaining_count_of_c

    for char, count in a_char_counts.items():
        result += char * count

    return result


def findK(a, b, c):
    a_char_counts = defaultdict(lambda: 0)
    b_char_counts = defaultdict(lambda: 0)
    c_char_counts = defaultdict(lambda: 0)

    for char in a:
        a_char_counts[char] += 1

    for char in b:
        b_char_counts[char] += 1

    for char in c:
        c_char_counts[char] += 1

    max_count_of_b = find_max_possible_substring(a, a_char_counts, b_char_counts)

    max_count_of_c = find_max_possible_substring(a, a_char_counts, c_char_counts)

    if max_count_of_b >= max_count_of_c:
        result = get_result(a_char_counts, b, max_count_of_b, b_char_counts, c_char_counts)
    else:
        result = get_result(a_char_counts, c, max_count_of_c, c_char_counts, b_char_counts)

    return result


if __name__ == '__main__':
    a = input()
    b = input()
    c = input()

    print(findK(a, b, c))
