#include <bits/stdc++.h>
using namespace std;

bool is_good(const string& s) {
    return s.find("good") != string::npos;
}

bool is_special(const string& s) {
    int n = (int)s.size();

    int last_g = -1;
    int first_d = -1;

    for (int i = 0; i < n; i++) {
        if (s[i] == 'g') last_g = i;
        if (s[i] == 'd' && first_d == -1) first_d = i;
    }

    if (last_g == -1 || first_d == -1) return false;

    return last_g < first_d && first_d - last_g - 1 >= 3;
}

bool solve_main(const string& S, const string& T) {
    int cdS = 0, coS = 0, cgS = 0;
    int cdT = 0, coT = 0, cgT = 0;

    for (char c : S) {
        if (c == 'd') cdS++;
        if (c == 'o') coS++;
        if (c == 'g') cgS++;
    }

    for (char c : T) {
        if (c == 'd') cdT++;
        if (c == 'o') coT++;
        if (c == 'g') cgT++;
    }

    if (cdS != cdT) return false;
    if (coS != coT) return false;
    if (cgS != cgT) return false;

    return is_special(S) == is_special(T);
}

bool solve_bruteforce(const string& S, const string& T) {
    if (S == T) return true;

    queue<string> q;
    unordered_set<string> visited;

    q.push(S);
    visited.insert(S);

    while (!q.empty()) {
        string cur = q.front();
        q.pop();

        int n = (int)cur.size();

        for (int i = 0; i + 1 < n; i++) {
            string nxt = cur;
            swap(nxt[i], nxt[i + 1]);

            if (is_good(nxt)) continue;
            if (visited.count(nxt)) continue;

            if (nxt == T) return true;

            visited.insert(nxt);
            q.push(nxt);
        }
    }

    return false;
}

bool validate_input_string(const string& s) {
    for (char c : s) {
        if (c != 'd' && c != 'o' && c != 'g') {
            return false;
        }
    }
    return !is_good(s);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int Q;
    cin >> Q;

    assert(1 <= Q && Q <= 200000);

    long long total_len = 0;

    while (Q--) {
        string S, T;
        cin >> S >> T;

        assert(!S.empty());
        assert(S.size() == T.size());

        total_len += (long long)S.size();

        assert(validate_input_string(S));
        assert(validate_input_string(T));

        bool ans;

        if ((int)S.size() <= 8) {
            bool brute = solve_bruteforce(S, T);
            bool main_ans = solve_main(S, T);

            assert(brute == main_ans);

            ans = brute;
        } else {
            ans = solve_main(S, T);
        }

        cout << (ans ? "Yes" : "No") << '\n';
    }

    assert(total_len <= 200000);

    return 0;
}