```go
package main

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

func readInt(reader *bufio.Reader) int64 {
	var res int64
	var sign int64 = 1
	var b byte
	var err error
	for {
		b, err = reader.ReadByte()
		if err != nil {
			return 0
		}
		if b >= '0' && b <= '9' {
			res = int64(b - '0')
			break
		}
		if b == '-' {
			sign = -1
		}
	}
	for {
		b, err = reader.ReadByte()
		if err != nil {
			break
		}
		if b >= '0' && b <= '9' {
			res = res*10 + int64(b-'0')
		} else {
			break
		}
	}
	return res * sign
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 64*1024)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	m := readInt(reader)
	k := readInt(reader)
	if m == 0 || k == 0 {
		return
	}

	S := make([]int64, k)
	P := make([]int64, k)

	for i := int64(0); i < k; i++ {
		var sum int64
		var sumSq int64
		for j := int64(0); j < m; j++ {
			x := readInt(reader)
			sum += x
			sumSq += x * x
		}
		S[i] = sum
		P[i] = sumSq
	}

	vDiff := make([]int64, k-1)
	for i := int64(0); i < k-1; i++ {
		vDiff[i] = S[i+1] - S[i]
	}

	sortedVDiff := make([]int64, k-1)
	copy(sortedVDiff, vDiff)
	sort.Slice(sortedVDiff, func(i, j int) bool { return sortedVDiff[i] < sortedVDiff[j] })

	V := sortedVDiff[(k-1)/2]

	var y int64 = -1
	for i := int64(1); i < k-1; i++ {
		if S[i] != S[0]+i*V {
			y = i
			break
		}
	}

	Delta := S[y] - (S[0] + y*V)

	var t1, t2 int64
	for i := int64(1); i <= 3; i++ {
		if i != y {
			if t1 == 0 {
				t1 = i
			} else if t2 == 0 {
				t2 = i
			}
		}
	}

	Y1 := (P[t1] - P[0]) / t1
	Y2 := (P[t2] - P[0]) / t2

	A := (Y2 - Y1) / (t2 - t1)
	B := Y1 - A*t1

	expectedPy := A*y*y + B*y + P[0]
	Delta2 := P[y] - expectedPy

	p := (Delta2 - Delta*Delta) / (2 * Delta)

	fmt.Fprintf(writer, "%d %d\n", y, p)
}
```