from sys import stdin
input = stdin.readline

class BIT:
    def __init__(self, A):
        self.size = len(A)
        self.bit = [0]*(len(A)+1)
        for i in range(len(A)):
            self.add(i, A[i])

    def sum(self, i):
        i += 1
        ans = 0
        while i > 0:
            ans += self.bit[i]
            i -= -i&i
        return ans
    
    def query(self, l, r):
        if l == 0:
            return self.sum(r-1)
        else:
            return self.sum(r-1)-self.sum(l-1)
    
    def add(self, i, x):
        i += 1
        while i <= self.size:
            self.bit[i] += x
            i += -i&i

def code(s):
    return ord(s)-ord("a")
def codeR(n):
    return chr(ord("a")+n)

def func(S):
    L, R = [], []
    for i, s in enumerate(S):
        if i%2 == 0:
            L.append(code(s))
        else:
            R.append(code(s))
    return L, R

def compress(A):
    S = sorted(set(A))
    D = dict()
    for i in range(len(S)):
        D[S[i]] = i
    return D

def InversionNumber(A):
    D = compress(A)
    L = len(D)
    B = BIT([0]*L)
    ans = 0
    for a in A:
        idx = D[a]
        if idx+1 < L:
            ans += B.query(idx+1, L)
        B.add(idx, 1)
    return ans

for _ in range(int(input())):
    S = input().rstrip("\n")
    T = input().rstrip("\n")
    N = len(S)

    SL, SR = func(S)
    TL, TR = func(T)

    if sorted(SL) != sorted(TL):
        print("No")
        continue
    if sorted(SR) != sorted(TR):
        print("No")
        continue

    if (len(set(SL)) < len(SL) or len(set(TL)) < len(TL) or
        len(set(SR)) < len(SR) or len(set(TR)) < len(TR)):
        print("Yes")
        continue

    a = InversionNumber(SL)%2 == InversionNumber(TL)%2
    b = InversionNumber(SR)%2 == InversionNumber(TR)%2
    print("Yes" if a == b else "No")