const MAX_T: usize = 10000;
const MAX_N: usize = 27;
const MAX_COST: f64 = 1e8;

// 与えられた比較交換器ネットワークがソーティングネットワークかどうかをチェック
fn is_sorting_network(n: usize, cmp: &[(usize, usize)]) -> Result<Vec<bool>, Vec<bool>> {
    type NodeIndex = u8;
    type CmpIndex = usize;
    type State = u64;
    const { assert!(MAX_N <= NodeIndex::MAX as _ && MAX_N * (MAX_N - 1) / 2 <= CmpIndex::MAX as _) };
    assert!(2 <= n && (n as usize) <= MAX_N && n <= u32::BITS as _);
    assert!(cmp.len() <= CmpIndex::MAX as _);
    // 0-indexed かつ a < b かつ b < n であることを確認
    assert!(cmp.iter().all(|&(a, b)| a < b && b < n));
    let cmp_thin = cmp
        .iter()
        .map(|&(a, b)| (a as NodeIndex, b as NodeIndex))
        .collect::<Vec<_>>();
    let _n = n as NodeIndex;
    // スタックに積む要素: 0状態ベクトル z, 1状態ベクトル o, 比較交換器の番号 i
    // もし ((z >> j) & 1, (o >> j) & 1) == (1, 1) なら j-bit目の状態は '?'
    // もし ((z >> j) & 1, (o >> j) & 1) == (1, 0) なら j-bit目の状態は '0'
    // もし ((z >> j) & 1, (o >> j) & 1) == (0, 1) なら j-bit目の状態は '1'
    // '0...01...1' または '0...0?1...1' の場合、ソートされている 
    // 初期状態: 0状態ベクトルは[0,n)-bit目が1、1状態ベクトルは全bitが1、比較交換器の番号は 0
    let mut stack = Vec::<(State, State, CmpIndex)>::with_capacity(n as _);
    stack.push((State::MAX >> (State::BITS - n as u32), State::MAX, 0));
    // unused[i]: i番目の要素がソーティングネットワークで使用されているか
    let mut unused = vec![true; cmp.len()];
    // unsorted[i]: i,(i+1)番目の要素ペアがソートされていない可能性があるか
    let mut unsorted = vec![false; (n - 1) as _];
    // 非再帰の深さ優先探索による分岐状態の探索
    'a: while let Some((mut z, mut o, i)) = stack.pop() {
        let mut i = i as usize;
        // 比較交換器を順に適用
        // 0,1状態ベクトル z,o の a,b-bit目が比較交換器の入出力
        while let Some(&(a, b)) = cmp_thin.get(i) {
            i += 1;
            match ((z >> a) & 1, (o >> a) & 1, (z >> b) & 1, (o >> b) & 1) {
                (1, 0, _, _) | (_, _, 0, 1) => {
                    // 比較交換器の入力が ('0', _) or (_, '1') {_ は任意を示す} の場合、
                    // 交換はないので次の比較交換器へ進む
                }
                (1, 1, 1, 1) => {
                    // この比較交換器は使用される可能性あり
                    unused[i - 1] = false;
                    // 比較交換器の入力が ('?', '?') であれば、 ('0', '0') と ('?', '1') に分岐して探索
                    // 新しい分岐は ('0', '0') に遷移
                    // 現在の分岐は ('?', '1') に遷移
                    let (qz, mut qo) = (z, o);
                    qo &= !(1 << a) & !(1 << b); // qz,qo: ('?', '?') -> ('0', '0')
                    z &= !(1 << b); // z,o: ('?', '?') -> ('?', '1')
                    // 新しい分岐の状態 'q' の非0要素の先頭を見つける
                    if (qz & !qo).trailing_ones() + (qo & !qz).leading_ones() < State::BITS - 1 {
                        // (qz,qo) がソートされていない場合、分岐をスタックに積む
                        stack.push((qz, qo, i as _));
                    }
                    // (z,o) がソート済みの場合、次の比較交換器へ進む
                    if (z & !o).trailing_ones() + (o & !z).leading_ones() >= State::BITS - 1 {
                        continue 'a;
                    }
                }
                _ => {
                    // この比較交換器は使用される可能性あり
                    unused[i - 1] = false;
                    // 比較交換器の入力が ('1', '0') or ('?', '0') or ('1', '?') の場合、要素を交換
                    let xz = ((z >> a) ^ (z >> b)) & 1;
                    let xo = ((o >> a) ^ (o >> b)) & 1;
                    z ^= xz << a | xz << b;
                    o ^= xo << a | xo << b;
                    // (z,o) がソート済みの場合、次の比較交換器へ進む
                    if (z & !o).trailing_ones() + (o & !z).leading_ones() >= State::BITS - 1 {
                        continue 'a;
                    }
                }
            }
        }
        // この分岐で全ての比較交換が完了し、z,o がソートされていない場合
        // ソートされていない位置をマーク
        for j in 0..(n as usize - 1) {
            match ((z >> j) & 1, (o >> j) & 1, (z >> (j + 1)) & 1, (o >> (j + 1)) & 1) {
                // ('0', '0') または ('1', '1') または ('0', '1') または ('0', '?') または ('?', '1') の場合
                // 操作なし
                (1, 0, _, _) | (_, _, 0, 1) => {}
                // ('?', '?') または ('?', '0') または ('1', '?') または ('1', '0') の場合
                // ソートされていないとマーク
                _ => {
                    unsorted[j] = true;
                }
            }
        }
    }
    // すべての分岐が終了
    // いずれかの分岐でソートされていない場合、 unsorted に true が含まれるのでソーティングネットワークではない
    if unsorted.iter().any(|&f| f) {
        // ソートされていない可能性のある位置を返す
        Err(unsorted)
    } else {
        // すべての分岐においてソートされたならばソーティングネットワーク
        // 未使用の比較交換器を返す
        Ok(unused)
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::io::Write;
    let execution_start = std::time::Instant::now();
    let stdin = std::io::stdin();
    let mut lines = std::io::BufRead::lines(stdin.lock());
    let mut bout = std::io::BufWriter::new(std::io::stdout());

    let t: usize = lines.next().unwrap()?.trim().parse()?;
    assert!(t <= MAX_T);

    // φ = (1 + √5) / 2 : 黄金数 1.618033988749895
    let phi = (1.25f64).sqrt() + 0.5;
    let mut cost = 0f64;

    for _ in 0..t {
        let line = lines.next().unwrap()?;
        let mut parts = line.split_whitespace();
        let n: usize = parts.next().unwrap().parse()?;
        let m: usize = parts.next().unwrap().parse()?;
        assert!(2 <= n && (n as usize) <= MAX_N);
        assert!(1 <= m && m <= (n as usize) * ((n as usize) - 1) / 2);
        cost += m as f64 * phi.powi(n as i32);
        // テストケースのコスト <= MAX_COST
        assert!(cost <= MAX_COST);

        // 比較交換器を読み込む
        let va = lines.next().unwrap()?.split_whitespace().map(|s| s.parse::<usize>().unwrap()).collect::<Vec<_>>();
        let vb = lines.next().unwrap()?.split_whitespace().map(|s| s.parse::<usize>().unwrap()).collect::<Vec<_>>();
        assert_eq!(va.len(), m);
        assert_eq!(vb.len(), m);
        assert!(va.iter().zip(vb.iter()).all(|(&a, &b)| 1 <= a && a < b && b <= n));
        // 1-indexed を 0-indexed に変換
        let cmp = va.iter().zip(vb.iter()).map(|(&a, &b)| (a - 1, b - 1)).collect::<Vec<_>>();

        // ソーティングネットワークかどうかをチェック
        match is_sorting_network(n, &cmp) {
            Ok(unused) => {
                writeln!(&mut bout, "Yes")?;
                // 未使用の比較交換器 j を列挙
                writeln!(&mut bout, "{}", unused.iter().filter(|&&f| f).count())?;
                // 1-indexed
                writeln!(
                    &mut bout,
                    "{}",
                    unused
                        .iter()
                        .enumerate()
                        .filter_map(|(j, &u)| if u { Some((j + 1).to_string()) } else { None })
                        .collect::<Vec<_>>()
                        .join(" ")
                )?;
            }
            Err(unsorted) => {
                writeln!(&mut bout, "No")?;
                // ソートされていない可能性がある位置 k を列挙
                writeln!(&mut bout, "{}", unsorted.iter().filter(|&&f| f).count())?;
                // 1-indexed
                writeln!(
                    &mut bout,
                    "{}",
                    unsorted
                        .iter()
                        .enumerate()
                        .filter_map(|(k, &u)| if u { Some((k + 1).to_string()) } else { None })
                        .collect::<Vec<_>>()
                        .join(" ")
                )?;
            }
        }
    }
    bout.flush()?;
    eprintln!("{} ms", execution_start.elapsed().as_millis());
    Ok(())
}