description: Monocarp is playing a computer game. Now he wants to complete the first level of this game.
  
  A level is a rectangular grid of 2 rows and n columns. Monocarp controls a character, which starts in cell (1, 1) — at the intersection of the 1-st row and the 1-st column.
  
  Monocarp's character can move from one cell to another in one step if the cells are adjacent by side and/or corner. Formally, it is possible to move from cell (x_1, y_1) to cell (x_2, y_2) in one step if |x_1 - x_2| ≤ 1 and |y_1 - y_2| ≤ 1. Obviously, it is prohibited to go outside the grid.
  
  There are traps in some cells. If Monocarp's character finds himself in such a cell, he dies, and the game ends.
  
  To complete a level, Monocarp's character should reach cell (2, n) — at the intersection of row 2 and column n.
  
  Help Monocarp determine if it is possible to complete the level.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. Then the test cases follow. Each test case consists of three lines.
  
  The first line contains a single integer n (3 ≤ n ≤ 100) — the number of columns.
  
  The next two lines describe the level. The i-th of these lines describes the i-th line of the level — the line consists of the characters '0' and '1'. The character '0' corresponds to a safe cell, the character '1' corresponds to a trap cell.
  
  Additional constraint on the input: cells (1, 1) and (2, n) are safe.
  
  Output
  
  For each test case, output YES if it is possible to complete the level, and NO otherwise.
  
  Example
  
  Input
  
  
  4
  3
  000
  000
  4
  0011
  1100
  4
  0111
  1110
  6
  010101
  101010
  
  
  Output
  
  
  YES
  YES
  NO
  YES
  
  Note
  
  Consider the example from the statement.
  
  In the first test case, one of the possible paths is (1, 1) → (2, 2) → (2, 3).
  
  In the second test case, one of the possible paths is (1, 1) → (1, 2) → (2, 3) → (2, 4).
  
  In the fourth test case, one of the possible paths is (1, 1) → (2, 2) → (1, 3) → (2, 4) → (1, 5) → (2, 6).
solution: #include <bits/stdc++.h>
  using namespace std;
  using ll = long long;
  using pii = pair<int, int>;
  using pll = pair<ll, ll>;
  using vi = vector<int>;
  using vii = vector<pii>;
  struct fast_ios {
    fast_ios() {
      cin.tie(nullptr);
      ios::sync_with_stdio(false);
      cout << fixed << setprecision(20);
    };
  } fast_ios_;
  template <typename T>
  void ndarray(vector<T> &vec, int len) {
    vec.resize(len);
  }
  template <typename T, typename... Args>
  void ndarray(vector<T> &vec, int len, Args... args) {
    vec.resize(len);
    for (auto &v : vec) ndarray(v, args...);
  }
  template <typename V, typename T>
  void ndfill(V &x, const T &val) {
    x = val;
  }
  template <typename V, typename T>
  void ndfill(vector<V> &vec, const T &val) {
    for (auto &v : vec) ndfill(v, val);
  }
  template <typename T>
  bool chmax(T &m, const T q) {
    if (m < q) {
      m = q;
      return true;
    } else
      return false;
  }
  template <typename T>
  bool chmin(T &m, const T q) {
    if (m > q) {
      m = q;
      return true;
    } else
      return false;
  }
  template <typename T1, typename T2>
  pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
    return make_pair(l.first + r.first, l.second + r.second);
  }
  template <typename T1, typename T2>
  pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
    return make_pair(l.first - r.first, l.second - r.second);
  }
  template <typename T>
  vector<T> srtunq(vector<T> vec) {
    sort(vec.begin(), vec.end()),
        vec.erase(unique(vec.begin(), vec.end()), vec.end());
    return vec;
  }
  template <typename T>
  istream &operator>>(istream &is, vector<T> &vec) {
    for (auto &v : vec) is >> v;
    return is;
  }
  template <typename T>
  ostream &operator<<(ostream &os, const vector<T> &vec) {
    os << '[';
    for (auto v : vec) os << v << ',';
    os << ']';
    return os;
  }
  template <typename T>
  ostream &operator<<(ostream &os, const deque<T> &vec) {
    os << "deq[";
    for (auto v : vec) os << v << ',';
    os << ']';
    return os;
  }
  template <typename T>
  ostream &operator<<(ostream &os, const set<T> &vec) {
    os << '{';
    for (auto v : vec) os << v << ',';
    os << '}';
    return os;
  }
  template <typename T>
  ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
    os << '{';
    for (auto v : vec) os << v << ',';
    os << '}';
    return os;
  }
  template <typename T>
  ostream &operator<<(ostream &os, const multiset<T> &vec) {
    os << '{';
    for (auto v : vec) os << v << ',';
    os << '}';
    return os;
  }
  template <typename T>
  ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
    os << '{';
    for (auto v : vec) os << v << ',';
    os << '}';
    return os;
  }
  template <typename T1, typename T2>
  ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
    os << '(' << pa.first << ',' << pa.second << ')';
    return os;
  }
  template <typename TK, typename TV>
  ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
    os << '{';
    for (auto v : mp) os << v.first << "=>" << v.second << ',';
    os << '}';
    return os;
  }
  template <typename TK, typename TV>
  ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
    os << '{';
    for (auto v : mp) os << v.first << "=>" << v.second << ',';
    os << '}';
    return os;
  }
  constexpr ll MOD = 1e9 + 7;
  void solve() {
    int n;
    cin >> n;
    vector<vector<int>> a(2, vector<int>(n));
    for (int i = 0; i < 2; i++) {
      for (int j = 0; j < n; j++) {
        char c;
        cin >> c;
        a[i][j] = c - '0';
      }
    }
    vector<int> b(n);
    for (int i = 0; i < n; i++) {
      if (a[0][i] == 1 && a[1][i] == 1) {
        cout << "NO" << endl;
        return;
      }
    }
    cout << "YES" << endl;
  }
  int main() {
    fast_ios_;
    int t;
    cin >> t;
    while (t--) {
      solve();
    }
    return 0;
  }
  