// https://atcoder.jp/contests/abc407/tasks/abc407_f

#include <iostream>
#include <string>
#include <vector>

typedef unsigned long long u64;

enum class Token {
  Left,
  Right,
  X
};

static inline Token get_token(char c)
{
  switch (c) {
  case '(':
    return Token::Left;
  case ')':
    return Token::Right;
  default:
    return Token::X;
  }
}

static inline bool to_reduce(const std::vector<Token>& stack)
{
  u64 n = stack.size();
  if (n < 3) return false;

  bool c1 = (stack[n-3] == Token::Left);
  bool c2 = (stack[n-2] == Token::X);
  bool c3 = (stack[n-1] == Token::X);

  return (c1 && c2 && c3);
}

static inline bool solve(const std::string& a, const std::string& b)
{
  // stacks for both strings
  std::vector<Token> stack_a;
  std::vector<Token> stack_b;
  
  // string a -> stack
  for (char c : a) {
    u64 n = stack_a.size();
    Token t = get_token(c);

    if (t == Token::Right && to_reduce(stack_a)) {
      stack_a.pop_back(); // 'x'
      stack_a.pop_back(); // 'x'
      stack_a.pop_back(); // '('
      
      stack_a.push_back(Token::X);
      stack_a.push_back(Token::X);
    } else {
      stack_a.push_back(t);
    }
  }

  // string b -> stack
  for (char c : b) {
    u64 n = stack_b.size();
    Token t = get_token(c);

    if (t == Token::Right && to_reduce(stack_b)) {
      stack_b.pop_back();
      stack_b.pop_back();
      stack_b.pop_back();

      stack_b.push_back(Token::X);
      stack_b.push_back(Token::X);
    } else {
      stack_b.push_back(t);
    }
  }

  // check if both stacks are identical
  if (stack_a.size() != stack_b.size()) return false;
  u64 n = stack_b.size();
  for (u64 i = 0; i < n; ++i) {
    if (stack_a[i] != stack_b[i]) return false;
  }

  return true;
}

int main(void)
{
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);

  int N;
  if (!(std::cin >> N)) return 0;

  while (N--) {
    std::string a;
    std::string b;
    std::cin >> a;
    std::cin >> b;

    std::cout << (solve(a, b) ? "Yes" : "No") << '\n';
  }
  
  return 0;
}