package main

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

var buffer []byte
var bpos, bsize int

func readInt() int64 {
	for bpos < bsize && buffer[bpos] <= 32 {
		bpos++
	}
	if bpos >= bsize {
		return 0
	}
	var res int64
	for bpos < bsize && buffer[bpos] > 32 {
		res = res*10 + int64(buffer[bpos]-'0')
		bpos++
	}
	return res
}

type FastHeap struct {
	data []uint64
	size int
}

func NewFastHeap(cap int) *FastHeap {
	return &FastHeap{
		data: make([]uint64, cap),
		size: 0,
	}
}

func (h *FastHeap) Push(x uint64) {
	j := h.size
	h.size++
	for j > 0 {
		i := (j - 1) / 2
		if h.data[i] <= x {
			break
		}
		h.data[j] = h.data[i]
		j = i
	}
	h.data[j] = x
}

func (h *FastHeap) Pop() uint64 {
	h.size--
	res := h.data[0]
	if h.size == 0 {
		return res
	}
	x := h.data[h.size]
	n := h.size
	i := 0
	half := n / 2
	for i < half {
		j := 2*i + 1
		if j+1 < n && h.data[j+1] < h.data[j] {
			j++
		}
		if x <= h.data[j] {
			break
		}
		h.data[i] = h.data[j]
		i = j
	}
	h.data[i] = x
	return res
}

type Seq struct {
	rem int32
	val int32
	x   int32
	y   int32
	m   int32
}

func main() {
	buffer, _ = io.ReadAll(os.Stdin)
	bsize = len(buffer)

	n := int(readInt())
	if n == 0 {
		return
	}

	seqs := make([]Seq, n)
	totalElements := int64(0)

	H1 := NewFastHeap(n)
	H2 := NewFastHeap(n)

	for i := 0; i < n; i++ {
		k := readInt()
		a1 := readInt()
		x := readInt()
		y := readInt()
		m := readInt()

		totalElements += k
		seqs[i] = Seq{
			rem: int32(k),
			val: int32(a1),
			x:   int32(x),
			y:   int32(y),
			m:   int32(m),
		}
		H1.Push((uint64(a1) << 32) | uint64(i))
	}

	var output []uint64
	if totalElements <= 200000 {
		output = make([]uint64, 0, totalElements)
	}

	descents := 0
	var currentLast int32 = -1

	for H1.size > 0 || H2.size > 0 {
		if H1.size == 0 {
			descents++
			H1, H2 = H2, H1
			currentLast = -1
		}

		entry := H1.Pop()
		val := int32(entry >> 32)
		seqIdx := int32(entry & 0xFFFFFFFF)

		currentLast = val

		if output != nil {
			output = append(output, entry)
		}

		s := &seqs[seqIdx]
		s.rem--
		if s.rem > 0 {
			s.val = int32((int64(s.val)*int64(s.x) + int64(s.y)) % int64(s.m))
			nextVal := s.val
			nextEntry := (uint64(nextVal) << 32) | uint64(seqIdx)
			if nextVal >= currentLast {
				H1.Push(nextEntry)
			} else {
				H2.Push(nextEntry)
			}
		}
	}

	fmt.Println(descents)
	if output != nil {
		out := bufio.NewWriterSize(os.Stdout, 65536)
		for _, entry := range output {
			val := int32(entry >> 32)
			seqIdx := int32(entry&0xFFFFFFFF) + 1
			writeInt(out, val)
			out.WriteByte(' ')
			writeInt(out, seqIdx)
			out.WriteByte('\n')
		}
		out.Flush()
	}
}

func writeInt(w *bufio.Writer, n int32) {
	if n == 0 {
		w.WriteByte('0')
		return
	}
	var buf [12]byte
	i := 11
	for n > 0 {
		buf[i] = byte(n%10 + '0')
		n /= 10
		i--
	}
	w.Write(buf[i+1:])
}