// Author: @Drydock
use std::io::{self, Read};

fn main() {
    solve();
}

fn solve() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut it = I::new(&input);
    let t: usize = it.n();
    let mut o = String::new();
    for _ in 0..t {
        let n: usize = it.n();
        let s: Vec<u8> = it.s();
        let p: Vec<u8> = it.s();
        if s == p {
            o.push_str("YES\n");
            continue;
        }
        if n == 1 {
            o.push_str("NO\n");
            continue;
        }
        if n == 2 {
            let ok = match (&s[..], &p[..]) {
                (b"00", b"01") | (b"00", b"10") => true,
                (b"11", b"01") | (b"11", b"10") => true,
                (b"01", b"01") | (b"01", b"10") => true,
                (b"10", b"01") | (b"10", b"10") => true,
                _ => false,
            };
            o.push_str(if ok { "YES\n" } else { "NO\n" });
            continue;
        }
        let mut a = false;
        let mut b = false;
        for i in 0..n - 1 {
            if s[i] != s[i + 1] {
                a = true;
            }
            if p[i] != p[i + 1] {
                b = true;
            }
        }
        o.push_str(if a || b { "YES\n" } else { "NO\n" });
    }
    print!("{}", o);
}

struct I<'a> {
    w: std::str::SplitWhitespace<'a>,
}

impl<'a> I<'a> {
    fn new(s: &'a str) -> Self {
        Self { w: s.split_whitespace() }
    }
    fn n<T: std::str::FromStr>(&mut self) -> T {
        self.w.next().unwrap().parse().ok().unwrap()
    }
    fn s(&mut self) -> Vec<u8> {
        self.w.next().unwrap().as_bytes().to_vec()
    }
}