package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for i := 0; i < t; i++ {
		var n, m int
		fmt.Fscan(reader, &n, &m)

		adj := make([][]int, n+1)
		for j := 0; j < m; j++ {
			var u, v int
			fmt.Fscan(reader, &u, &v)
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		solve(n, m, adj, writer)
	}
}

func solve(n, m int, adj [][]int, writer *bufio.Writer) {
	for u := 1; u <= n; u++ {
		if len(adj[u]) < 4 {
			continue
		}

		visited := make([]bool, n+1)
		root := make([]int, n+1)
		parent := make([]int, n+1)

		q := []int{}
		for _, v := range adj[u] {
			visited[v] = true
			root[v] = v
			parent[v] = v
			q = append(q, v)
		}
		visited[u] = true

		found := false
		var cycleEdges [][2]int
		var cycleNodes []bool

		for len(q) > 0 {
			c := q[0]
			q = q[1:]

			for _, nx := range adj[c] {
				if nx == u {
					continue
				}
				if visited[nx] {
					if root[nx] != root[c] {
						found = true
						cycleEdges = make([][2]int, 0)
						cycleNodes = make([]bool, n+1)

						curr := c
						for curr != root[curr] {
							p := parent[curr]
							cycleEdges = append(cycleEdges, [2]int{curr, p})
							cycleNodes[curr] = true
							cycleNodes[p] = true
							curr = p
						}
						cycleEdges = append(cycleEdges, [2]int{root[c], u})
						cycleNodes[root[c]] = true
						cycleNodes[u] = true

						curr = nx
						for curr != root[curr] {
							p := parent[curr]
							cycleEdges = append(cycleEdges, [2]int{curr, p})
							cycleNodes[curr] = true
							cycleNodes[p] = true
							curr = p
						}
						cycleEdges = append(cycleEdges, [2]int{root[nx], u})
						cycleNodes[root[nx]] = true

						cycleEdges = append(cycleEdges, [2]int{c, nx})
						cycleNodes[c] = true
						cycleNodes[nx] = true

						break
					}
				} else {
					visited[nx] = true
					root[nx] = root[c]
					parent[nx] = c
					q = append(q, nx)
				}
			}
			if found {
				break
			}
		}

		if found {
			extra := 0
			for _, v := range adj[u] {
				if !cycleNodes[v] {
					cycleEdges = append(cycleEdges, [2]int{u, v})
					extra++
					if extra == 2 {
						break
					}
				}
			}

			fmt.Fprintln(writer, "YES")
			fmt.Fprintln(writer, len(cycleEdges))
			for _, edge := range cycleEdges {
				fmt.Fprintln(writer, edge[0], edge[1])
			}
			return
		}
	}
	fmt.Fprintln(writer, "NO")
}