package main

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

type FastReader struct {
	r *bufio.Reader
}

func NewFastReader() *FastReader {
	return &FastReader{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fr *FastReader) NextInt64() int64 {
	var sign int64 = 1
	var val int64 = 0
	c, _ := fr.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = fr.r.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = fr.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int64(c-'0')
		c, _ = fr.r.ReadByte()
	}
	return val * sign
}

func max64(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}
func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func ceilDiv(a, b int64) int64 {
	if b < 0 {
		a = -a
		b = -b
	}
	if a >= 0 {
		return (a + b - 1) / b
	}
	return a / b
}

func computeLR(a []int64, n int, T, D int64) (int64, int64, bool) {
	Lprev := int64(0)
	Rprev := int64(0)
	for i := 1; i <= n-1; i++ {
		L := a[i]
		t := Lprev + T
		if t > L {
			L = t
		}
		R := a[i+1]
		tmp := Rprev + T + D
		if tmp < R {
			R = tmp
		}
		if L > R {
			return 0, 0, false
		}
		Lprev = L
		Rprev = R
	}
	return Lprev, Rprev, true
}

func feasibleForD(a []int64, n int, l int64, D int64) (bool, int64, int64) {
	if n == 0 {
		return false, 0, 0
	}
	// T in [Tlo, Thi]
	Tlo := ceilDiv(l-int64(n)*D, int64(n))
	if Tlo < 1 {
		Tlo = 1
	}
	Thi := l / int64(n)
	if Tlo > Thi {
		return false, 0, 0
	}
	// find minimal T with R(T)+T+D >= l
	lo := Tlo
	hi := Thi
	ansLow := int64(-1)
	for lo <= hi {
		mid := (lo + hi) / 2
		_, R, ok := computeLR(a, n, mid, D)
		if ok && R+mid+D >= l {
			ansLow = mid
			hi = mid - 1
		} else {
			lo = mid + 1
		}
	}
	if ansLow == -1 {
		return false, 0, 0
	}
	// find maximal T with L(T)+T <= l
	lo = Tlo
	hi = Thi
	ansHigh := int64(-1)
	for lo <= hi {
		mid := (lo + hi) / 2
		L, _, ok := computeLR(a, n, mid, D)
		if ok && L+mid <= l {
			ansHigh = mid
			lo = mid + 1
		} else {
			hi = mid - 1
		}
	}
	if ansHigh == -1 || ansLow > ansHigh {
		return false, 0, 0
	}
	return true, ansLow, ansHigh
}

func main() {
	in := NewFastReader()
	l := in.NextInt64()
	n64 := in.NextInt64()
	n := int(n64)
	a := make([]int64, n+1+1)
	for i := 1; i <= n; i++ {
		a[i] = in.NextInt64()
	}
	// Binary search minimal D
	loD := int64(0)
	hiD := l
	var bestD int64
	var bestT int64
	for loD < hiD {
		midD := (loD + hiD) / 2
		ok, tLow, tHigh := feasibleForD(a, n, l, midD)
		if ok {
			hiD = midD
		} else {
			loD = midD + 1
		}
		_ = tLow
		_ = tHigh
	}
	bestD = loD
	// Find a feasible T for bestD
	ok, tLow, tHigh := feasibleForD(a, n, l, bestD)
	if !ok {
		// Should not happen for valid inputs
		return
	}
	bestT = tLow
	if bestT < 1 {
		bestT = 1
	}
	if bestT > tHigh {
		bestT = tHigh
	}
	// Build intervals LL, RR for S_i (i=0..n-1)
	LL := make([]int64, n)
	RR := make([]int64, n)
	LL[0] = 0
	RR[0] = 0
	for i := 1; i <= n-1; i++ {
		L := a[i]
		t := LL[i-1] + bestT
		if t > L {
			L = t
		}
		R := a[i+1]
		tmp := RR[i-1] + bestT + bestD
		if tmp < R {
			R = tmp
		}
		LL[i] = L
		RR[i] = R
	}
	// Reconstruct S
	S := make([]int64, n+1)
	S[n] = l
	if n >= 1 {
		low := max64(LL[n-1], l-(bestT+bestD))
		high := min64(RR[n-1], l-bestT)
		if high < low {
			high = low
		}
		S[n-1] = high
		for i := n - 1; i >= 1; i-- {
			low = max64(LL[i-1], S[i]-(bestT+bestD))
			high = min64(RR[i-1], S[i]-bestT)
			if high < low {
				high = low
			}
			S[i-1] = high
		}
	}
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	for i := 1; i <= n; i++ {
		fmt.Fprintln(out, S[i-1], S[i])
	}
	out.Flush()
}