package main

import (
	"fmt"
	"io"
	"os"
	"sort"
)

type Scanner struct {
	b   []byte
	pos int
}

func (s *Scanner) NextInt() int {
	for s.pos < len(s.b) && (s.b[s.pos] < '0' || s.b[s.pos] > '9') {
		s.pos++
	}
	if s.pos >= len(s.b) {
		return 0
	}
	res := 0
	for s.pos < len(s.b) && s.b[s.pos] >= '0' && s.b[s.pos] <= '9' {
		res = res*10 + int(s.b[s.pos]-'0')
		s.pos++
	}
	return res
}

type User struct {
	id   int
	acts []int
}

func main() {
	b, _ := io.ReadAll(os.Stdin)
	s := &Scanner{b: b, pos: 0}

	n := s.NextInt()
	m := s.NextInt()
	if n == 0 {
		return
	}

	users := make([]User, n)
	for i := 0; i < n; i++ {
		k := s.NextInt()
		users[i] = User{id: i + 1, acts: make([]int, k)}
		for j := 0; j < k; j++ {
			users[i].acts[j] = s.NextInt()
		}
	}

	sort.Slice(users, func(i, j int) bool {
		return len(users[i].acts) < len(users[j].acts)
	})

	rep := make([]int, m+1)
	inU := make([]bool, m+1)
	isChecked := make([]int, n)

	for u := 0; u < n; u++ {
		for _, x := range users[u].acts {
			inU[x] = true
		}

		for _, x := range users[u].acts {
			vPlus1 := rep[x]
			if vPlus1 == 0 {
				rep[x] = u + 1
				continue
			}
			v := vPlus1 - 1

			if isChecked[v] == u+1 {
				rep[x] = u + 1
				continue
			}
			isChecked[v] = u + 1

			isSubset := true
			for _, y := range users[v].acts {
				if !inU[y] {
					isSubset = false
					break
				}
			}

			if !isSubset {
				fmt.Println("YES")
				fmt.Printf("%d %d\n", users[v].id, users[u].id)
				return
			}

			rep[x] = u + 1
		}

		for _, x := range users[u].acts {
			inU[x] = false
		}
	}

	fmt.Println("NO")
}