use std::cmp::min;
use std::io::{self, BufRead, Write};

fn main() {
    let stdin = io::stdin();
    let mut reader = stdin.lock().lines();
    let mut input = String::new();
    while let Some(line) = reader.next() {
        match line {
            Ok(l) => input.push_str(&l),
            Err(_) => break,
        }
    }
    let mut tokens = input.split_whitespace();
    let cas: usize = tokens.next().unwrap().parse().unwrap();
    let stdout = io::stdout();
    let mut writer = io::BufWriter::new(stdout.lock());
    for _ in 0..cas {
        let n: usize = tokens.next().unwrap().parse().unwrap();
        let k: usize = tokens.next().unwrap().parse().unwrap();
        let mut c = vec![0i32; k];
        let mut tp: Option<usize> = None;
        let mut op: Option<usize> = None;
        let mut cc = [0usize, 0usize];
        for i in 0..k {
            c[i] = tokens.next().unwrap().parse().unwrap();
            if c[i] >= 2 {
                tp = Some(i);
            } else {
                cc[c[i] as usize] += 1;
                if c[i] == 1 {
                    op = Some(i);
                }
            }
        }
        if let Some(tp_idx) = tp {
            writeln!(writer, "{}", n - 1).unwrap();
            for i in 1..n {
                writeln!(writer, "1 {} {}", i + 1, tp_idx + 1).unwrap();
            }
            continue;
        }
        let mut t: usize = 0;
        let mut sp: usize = 1;
        let mut psp: usize = 1;
        while t * (k - 1) + (sp.saturating_sub(1)) * cc[1] < n - 1 {
            while t == sp * (sp - 1) / 2 {
                sp += 1;
            }
            psp = sp;
            t += 1;
        }
        let mut rq: usize = t * (k - 1) + (sp.saturating_sub(1)) * cc[1] - (n - 1);
        if cc[1] == 0 {
            sp = 1;
        }
        let total_pairs = sp * (sp - 1) / 2;
        let mut q = vec![Vec::new(); total_pairs];
        let mut rs = Vec::new();
        for i in 0..k {
            let mut qc = t;
            if c[i] > 0 {
                qc += sp - 1;
            }
            let rd = if let Some(op_idx) = op {
                if op_idx == i {
                    0
                } else {
                    min(rq, min(1 + if psp != sp && c[i] == 1 { 1 } else { 0 }, qc))
                }
            } else {
                min(rq, min(1 + if psp != sp && c[i] == 1 { 1 } else { 0 }, qc))
            };
            let mut rd = min(rq, min(1 + if psp != sp && c[i] == 1 { 1 } else { 0 }, qc));
            if op == Some(i) {
                rd = 0;
            }
            qc -= rd;
            rq -= rd;
            let start = if c[i] > 0 { 0 } else { sp - 1 };
            for j in start..total_pairs {
                if qc == 0 {
                    break;
                }
                q[j].push(i);
                qc -= 1;
            }
            rs.push((qc, i));
        }
        rs.sort();
        assert!((rs.last().unwrap().0 as isize - rs.first().unwrap().0 as isize).abs() <= 1);
        let mut ans = Vec::new();
        let mut ind = sp;
        let mut id = 0;
        for i in 0..sp {
            for j in (i + 1)..sp {
                if id >= q.len() {
                    break;
                }
                if q[id].is_empty() {
                    id += 1;
                    continue;
                }
                let x = q[id].pop().unwrap();
                let mut lst = i;
                for &y in &q[id] {
                    ans.push((lst, ind, y));
                    lst = ind;
                    ind += 1;
                }
                ans.push((lst, j, x));
                id += 1;
            }
        }
        while rs.last().unwrap().0 > 0 {
            let mut fst: Option<usize> = None;
            let mut lst: usize = 0;
            for (cn, x) in &mut rs {
                if *cn > 0 {
                    *cn -= 1;
                    if fst.is_none() {
                        fst = Some(*x);
                    } else if let Some(fst_val) = fst {
                        ans.push((lst, ind, *x));
                        lst = ind;
                        ind += 1;
                    }
                }
            }
            if let Some(fst_val) = fst {
                ans.push((lst, 0, fst_val));
            }
        }
        assert!(ans.len() == n - 1 + t);
        writeln!(writer, "{}", ans.len()).unwrap();
        for (x, y, v) in ans {
            writeln!(writer, "{} {} {}", x + 1, y + 1, v + 1).unwrap();
        }
    }
}