Problem: After the fourth season Sherlock and Moriary have realized the whole foolishness of the battle between them and decided to continue their competitions in peaceful game of Credit Cards.

Rules of this game are simple: each player bring his favourite n-digit credit card. Then both players name the digits written on their cards one by one. If two digits are not equal, then the player, whose digit is smaller gets a flick (knock in the forehead usually made with a forefinger) from the other player. For example, if n = 3, Sherlock's card is 123 and Moriarty's card has number 321, first Sherlock names 1 and Moriarty names 3 so Sherlock gets a flick. Then they both digit 2 so no one gets a flick. Finally, Sherlock names 3, while Moriarty names 1 and gets a flick.

Of course, Sherlock will play honestly naming digits one by one in the order they are given, while Moriary, as a true villain, plans to cheat. He is going to name his digits in some other order (however, he is not going to change the overall number of occurences of each digit). For example, in case above Moriarty could name 1, 2, 3 and get no flicks at all, or he can name 2, 3 and 1 to give Sherlock two flicks.

Your goal is to find out the minimum possible number of flicks Moriarty will get (no one likes flicks) and the maximum possible number of flicks Sherlock can get from Moriarty. Note, that these two goals are different and the optimal result may be obtained by using different strategies.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of digits in the cards Sherlock and Moriarty are going to use.

The second line contains n digits — Sherlock's credit card number.

The third line contains n digits — Moriarty's credit card number.

Output

First print the minimum possible number of flicks Moriarty will get. Then print the maximum possible number of flicks that Sherlock can get from Moriarty.

Examples

Input

3
123
321


Output

0
2


Input

2
88
00


Output

2
0

Note

First sample is elaborated in the problem statement. In the second sample, there is no way Moriarty can avoid getting two flicks.

Solution (in PYTHON3):

Solution:
# https://codeforces.com/problemset/problem/777/B
# Problem
# Big O:
# Time complexity: O(n log (n)) + 2*(O(n) + O(n))*O(k) = O(n)*O(k)
# Space complexity: 3*O(n) = O(n)

# Problem


def value_index_greater_or_equal_than(ordered_list, number):
    for i in range(0, len(ordered_list)):
        element = ordered_list[i]
        if element >= number:
            return i
    return -1


# def flicks(sherlocks_card, sorted_moriarty_card, prefer_greater_digit):
#     moriartys_flicks = 0
#     sherlocks_flicks = 0

#     for sherlocks_digit in sherlocks_card:
#         increment = 1 if prefer_greater_digit else 0
#         index = value_index_greater_or_equal_than(
#             sorted_moriarty_card, sherlocks_digit + increment)
#         index = index if index >= 0 else 0
#         moriartys_digit = sorted_moriarty_card[index]
#         if (moriartys_digit > sherlocks_digit):
#             sherlocks_flicks += 1
#         elif (moriartys_digit < sherlocks_digit):
#             moriartys_flicks += 1
#         sorted_moriarty_card.pop(index)
#     return moriartys_flicks, sherlocks_flicks


# def minimum_moriartys_flicks(sherlocks_card, sorted_moriarty_card):
#     moriartys_flicks, _ = flicks(sherlocks_card, sorted_moriarty_card, False)
#     return moriartys_flicks


# def maximum_sherlocks_flicks(sherlocks_card, sorted_moriarty_card):
#     _, sherlocks_flicks = flicks(sherlocks_card, sorted_moriarty_card, True)
#     return sherlocks_flicks


def minimum_moriartys_flicks(sherlocks_card, sorted_moriarty_card):
    moriartys_flicks = 0
    for digit in sherlocks_card:
        # guarantees minimum possible number of flicks Moriarty will get
        index = value_index_greater_or_equal_than(
            sorted_moriarty_card, digit)
        if (index >= 0):
            sorted_moriarty_card.pop(index)
        else:
            moriartys_flicks += 1
            sorted_moriarty_card.pop(0)
    return moriartys_flicks


def maximum_sherlocks_flicks(sherlocks_card, sorted_moriarty_card):
    sherlocks_flicks = 0
    for digit in sherlocks_card:
        # guarantees maximum possible number of flicks that Sherlock can get from Moriarty
        index = value_index_greater_or_equal_than(
            sorted_moriarty_card, digit + 1)
        if (index >= 0):
            sherlocks_flicks += 1
            sorted_moriarty_card.pop(index)
        else:
            sorted_moriarty_card.pop(0)
    return sherlocks_flicks


def solve_old(number_of_digits, sherlocks_card, moriartys_card):
    moriartys_card.sort()
    min_moriartys_flicks = minimum_moriartys_flicks(
        sherlocks_card, moriartys_card.copy())
    max_sherlocks_flicks = maximum_sherlocks_flicks(
        sherlocks_card, moriartys_card.copy())

    return min_moriartys_flicks, max_sherlocks_flicks


def get_digits_occurrences(card):
    occurrences = {}
    for digit in card:
        digit_occurrences = occurrences.get(digit, 0)
        occurrences[digit] = digit_occurrences + 1
    return occurrences


def find_greater_or_equal_digit(digit, digit_occurrences):
    for i in range(digit, 10):
        occurrences = digit_occurrences.get(i, -1)
        if occurrences > 0:
            return i

    return -1


def find_mimimum_digit(digit_occurrences):
    for i in range(0, 10):
        occurrences = digit_occurrences.get(i, -1)
        if occurrences > 0:
            return i
    return -1


def find_next_moriatys_digit(sherlocks_digit, digit_occurrences):
    # Looks for greater or equal digit
    digit_found = find_greater_or_equal_digit(
        sherlocks_digit, digit_occurrences)

    if (digit_found >= 0):
        return digit_found

    # Looks for minimum digit, since greater or equal was not found
    return find_mimimum_digit(digit_occurrences)


def find_minimum_moriartys_flicks(sherlocks_card, moriartys_digits_occurrences):
    moriartys_flicks = 0
    for sherlocks_digit in sherlocks_card:
        # looking for a digit greater or queal than sherlocks guarantees minimum possible number of flicks Moriarty will get
        moriartys_digit = find_next_moriatys_digit(
            sherlocks_digit, moriartys_digits_occurrences)
        if (sherlocks_digit > moriartys_digit):
            moriartys_flicks += 1
        moriartys_digits_occurrences[moriartys_digit] = moriartys_digits_occurrences[moriartys_digit] - 1
    return moriartys_flicks


def find_maximum_sherlocks_flicks(sherlocks_card, moriartys_digits_occurrences):
    sherlocks_flicks = 0
    for sherlocks_digit in sherlocks_card:
        # looking for a digit greater than sherlocks guarantees maximum possible number of flicks that Sherlock can get from Moriarty
        moriartys_digit = find_next_moriatys_digit(
            sherlocks_digit + 1, moriartys_digits_occurrences)
        if (moriartys_digit > sherlocks_digit):
            sherlocks_flicks += 1
        moriartys_digits_occurrences[moriartys_digit] = moriartys_digits_occurrences[moriartys_digit] - 1
    return sherlocks_flicks


def solve(number_of_digits, sherlocks_card, moriartys_card):
    moriartys_digits_occurrences = get_digits_occurrences(moriartys_card)
    moriartys_flicks = find_minimum_moriartys_flicks(
        sherlocks_card, moriartys_digits_occurrences.copy())
    sherlocks_flicks = find_maximum_sherlocks_flicks(
        sherlocks_card, moriartys_digits_occurrences.copy())
    return moriartys_flicks, sherlocks_flicks


# Read input
number_of_digits = int(input())
sherlocks_card = [int(x) for x in input()]
moriartys_card = [int(x) for x in input()]
moriartys_flicks, sherlocks_flicks = solve(
    number_of_digits, sherlocks_card, moriartys_card)
print(moriartys_flicks)
print(sherlocks_flicks)