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 = 'from operator import itemgetter\n\n\nclass BIT():\n    def __init__(self, n):\n        \'\'\'n = 要素数\n        要素の添字iは 0 <= i < n となる\n        \'\'\'\n        self.n = n\n        self.bit = [0] * (n + 1)\n \n    def add(self, i, val):\n        \'\'\'i番目の要素にvalを加算する O(logN)\'\'\'\n        i = i + 1\n        while i <= self.n:\n            self.bit[i] += val\n            i += i & -i\n \n    def _sum(self, i):\n        s = 0\n        while i > 0:\n            s += self.bit[i]\n            i -= i & -i\n        return s\n \n    def sum(self, i, j):\n        \'\'\'区間[i, j)の和を求める O(logN)\'\'\'\n        return self._sum(j) - self._sum(i)\n\n\ndef run_length_compress(string):\n    string.append("@")\n    n = len(string)\n\n    begin = 0\n    end = 1\n    cnt = 1\n    ans = []\n    while True:\n        if end >= n:\n            break\n        if string[begin] == string[end]:\n            end += 1\n            cnt += 1\n        else:\n            ans.append((cnt, string[begin]))\n            begin = end\n            end = begin + 1\n            cnt = 1\n\n    return ans\n\n\nq = int(input())\nfor _ in range(q):\n    n = int(input())\n    s = list(input())\n    t = list(input())\n    tmp_s = sorted(s)\n    tmp_t = sorted(t)\n    s_run = run_length_compress(tmp_s)\n    t_run = run_length_compress(tmp_t)\n    flag = False\n    f = False\n    for i in range(len(s_run)):\n        if s_run[i][0] >= 2:\n            flag = True\n        if s_run[i] != t_run[i]:\n            print("NO")\n            f = True\n            break\n    if f:\n        continue\n    if flag:\n        print("YES")\n        continue\n    cnt_s = 0\n    cnt_t = 0\n    for i in range(n)[::-1]:\n        for j in range(i):\n            if s[j] > s[j+1]:\n                s[j], s[j+1] = s[j+1], s[j]\n                cnt_s += 1\n            if t[j] > t[j+1]:\n                t[j], t[j+1] = t[j+1], t[j]\n                cnt_t += 1\n    if cnt_s % 2 == cnt_t % 2:\n        print("YES")\n    else:\n        print("NO")\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 16961