package main

import (
	"bufio"
	"os"
)

type FastScanner struct {
	r *bufio.Reader
}

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

func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func main() {
	fs := &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
	n := fs.NextInt64()
	m := fs.NextInt64()

	d := fs.NextInt64()
	h := fs.NextInt64()

	firstD, firstH := d, h
	prevD, prevH := d, h
	ans := firstH + firstD - 1
	possible := true

	for i := int64(1); i < m; i++ {
		cd := fs.NextInt64()
		ch := fs.NextInt64()

		dist := cd - prevD
		diff := abs(ch - prevH)
		if diff > dist {
			possible = false
			break
		}
		cur := max(prevH, ch) + (dist-diff)/2
		ans = max(ans, cur)

		prevD, prevH = cd, ch
	}

	if !possible {
		os.Stdout.WriteString("IMPOSSIBLE")
		return
	}

	ans = max(ans, prevH+n-prevD)

	w := bufio.NewWriterSize(os.Stdout, 32)
	defer w.Flush()

	var buf [32]byte
	x := ans
	if x == 0 {
		w.WriteByte('0')
		return
	}
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	w.Write(buf[i:])

	_ = firstD
	_ = firstH
}