You are given two strings $s$ and $t$ both of length $n$ and both consisting of lowercase Latin letters.

In one move, you can choose any length $len$ from $1$ to $n$ and perform the following operation:   Choose any contiguous substring of the string $s$ of length $len$ and reverse it;  at the same time choose any contiguous substring of the string $t$ of length $len$ and reverse it as well. 

Note that during one move you reverse exactly one substring of the string $s$ and exactly one substring of the string $t$.

Also note that borders of substrings you reverse in $s$ and in $t$ can be different, the only restriction is that you reverse the substrings of equal length. For example, if $len=3$ and $n=5$, you can reverse $s[1 \dots 3]$ and $t[3 \dots 5]$, $s[2 \dots 4]$ and $t[2 \dots 4]$, but not $s[1 \dots 3]$ and $t[1 \dots 2]$.

Your task is to say if it is possible to make strings $s$ and $t$ equal after some (possibly, empty) sequence of moves.

You have to answer $q$ independent test cases.


-----Input-----

The first line of the input contains one integer $q$ ($1 \le q \le 10^4$) — the number of test cases. Then $q$ test cases follow.

The first line of the test case contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$) — the length of $s$ and $t$.

The second line of the test case contains one string $s$ consisting of $n$ lowercase Latin letters.

The third line of the test case contains one string $t$ consisting of $n$ lowercase Latin letters.

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 10^5$ ($\sum n \le 2 \cdot 10^5$).


-----Output-----

For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings $s$ and $t$ equal after some (possibly, empty) sequence of moves and "NO" otherwise.


-----Example-----
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc

Output
NO
YES
NO
YES

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'q = int(input())\n\n# Python 3 program to count inversions in an array \n\n# Function to Use Inversion Count \ndef mergeSort(arr, n): \n\t# A temp_arr is created to store \n\t# sorted array in merge function \n\ttemp_arr = [0]*n \n\treturn _mergeSort(arr, temp_arr, 0, n-1) \n\n# This Function will use MergeSort to count inversions \n\ndef _mergeSort(arr, temp_arr, left, right): \n\n\t# A variable inv_count is used to store \n\t# inversion counts in each recursive call \n\n\tinv_count = 0\n\n\t# We will make a recursive call if and only if \n\t# we have more than one elements \n\n\tif left < right: \n\n\t\t# mid is calculated to divide the array into two subarrays \n\t\t# Floor division is must in case of python \n\n\t\tmid = (left + right)//2\n\n\t\t# It will calculate inversion counts in the left subarray \n\n\t\tinv_count = _mergeSort(arr, temp_arr, left, mid) \n\n\t\t# It will calculate inversion counts in right subarray \n\n\t\tinv_count += _mergeSort(arr, temp_arr, mid + 1, right) \n\n\t\t# It will merge two subarrays in a sorted subarray \n\n\t\tinv_count += merge(arr, temp_arr, left, mid, right) \n\treturn inv_count \n\n# This function will merge two subarrays in a single sorted subarray \ndef merge(arr, temp_arr, left, mid, right): \n\ti = left\t # Starting index of left subarray \n\tj = mid + 1 # Starting index of right subarray \n\tk = left\t # Starting index of to be sorted subarray \n\tinv_count = 0\n\n\t# Conditions are checked to make sure that i and j don\'t exceed their \n\t# subarray limits. \n\n\twhile i <= mid and j <= right: \n\n\t\t# There will be no inversion if arr[i] <= arr[j] \n\n\t\tif arr[i] <= arr[j]: \n\t\t\ttemp_arr[k] = arr[i] \n\t\t\tk += 1\n\t\t\ti += 1\n\t\telse: \n\t\t\t# Inversion will occur. \n\t\t\ttemp_arr[k] = arr[j] \n\t\t\tinv_count += (mid-i + 1) \n\t\t\tk += 1\n\t\t\tj += 1\n\n\t# Copy the remaining elements of left subarray into temporary array \n\twhile i <= mid: \n\t\ttemp_arr[k] = arr[i] \n\t\tk += 1\n\t\ti += 1\n\n\t# Copy the remaining elements of right subarray into temporary array \n\twhile j <= right: \n\t\ttemp_arr[k] = arr[j] \n\t\tk += 1\n\t\tj += 1\n\n\t# Copy the sorted subarray into Original array \n\tfor loop_var in range(left, right + 1): \n\t\tarr[loop_var] = temp_arr[loop_var] \n\t\t\n\treturn inv_count \n\n\nfor i in range(q):\n    l = int(input())\n    s1 = input()\n    s2 = input()\n\n    if sorted(s1) != sorted(s2):\n        print("NO")\n        continue\n\n    if len(s1) != len(set(s1)): print("YES"); continue\n    if len(s2) != len(set(s2)): print("YES"); continue\n\n    arr = [s2.index(c) for c in s1]\n    \n    \n    if mergeSort(arr, len(arr)) % 2 == 0:\n        print("YES")\n    else:\n        print("NO")\n    \n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 13271