package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}

func main() {
	fp := os.Stdin
	if len(os.Args) > 1 {
		fp, _ = os.Open(os.Args[1])
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(os.Stdout)

	k := getNextInt(scanner)
	x := getNextInt(scanner)
	y := getNextInt(scanner)
	if k%2 == 0 && k%2 != (x+y)%2 {
		fmt.Fprintln(writer, -1)
		writer.Flush()
		return
	}
	ans := make([][2]int, 0)
	px := x
	py := y
	if px < 0 {
		px = -px
	}
	if py < 0 {
		py = -py
	}

	ans = ap(px, py, ans)

	for px+py >= k*2 {
		if px > k {
			ans = ap(px-k, py, ans)
			px -= k
			continue
		}
		ans = ap(px, py-k, ans)
		py -= k
	}

	if absint(px)+absint(py) != k {
		if k%2 == 1 && (px+py)%2 == 1 {
			if px+py < k {
				ans = ap(px+k, py, ans)
				px += k
			} else if py > k {
				ans = ap(px, py-k, ans)
				py -= k
			} else {
				ans = ap(px-k, py, ans)
				px -= k
			}
		}
		fk := float64(k)
		var ll1, ll2 [4]Line

		dx := [4]float64{
			-fk,
			0.0,
			fk,
			0.0,
		}
		dy := [4]float64{
			0.0,
			-fk,
			0.0,
			fk,
		}

		for i := 0; i < 4; i++ {
			p1 := Point{
				x: 0.0 + dx[i],
				y: 0.0 + dy[i],
			}
			p2 := Point{
				x: 0.0 + dx[(i+1)%4],
				y: 0.0 + dy[(i+1)%4],
			}
			ll1[i].init(p1, p2)
		}
		for i := 0; i < 4; i++ {
			p1 := Point{
				x: float64(px) + dx[i],
				y: float64(py) + dy[i],
			}
			p2 := Point{
				x: float64(px) + dx[(i+1)%4],
				y: float64(py) + dy[(i+1)%4],
			}
			ll2[i].init(p1, p2)
		}

		p := firstPoint(ll1, ll2, fk)

		ans = ap(int(p.x), int(p.y), ans)
	}

	fmt.Fprintln(writer, len(ans))
	for i := len(ans) - 1; i >= 0; i-- {
		if x < 0 {
			ans[i][0] *= -1
		}
		if y < 0 {
			ans[i][1] *= -1
		}
		fmt.Fprintln(writer, fmt.Sprintf("%d %d", ans[i][0], ans[i][1]))
	}
	writer.Flush()
}

func ap(x, y int, ans [][2]int) [][2]int {
	ans = append(ans, [2]int{
		x,
		y,
	})
	return ans
}
func firstPoint(ll1, ll2 [4]Line, fk float64) Point {
	for i := 0; i < 4; i++ {
		for ii := 0; ii < 4; ii++ {
			if ll1[i].isCross(ll2[ii]) == false {
				continue
			}
			p := ll1[i].crossPoint(ll2[ii])
			if p.x != float64(int(p.x)) {
				continue
			}
			if p.y != float64(int(p.y)) {
				continue
			}
			if p.x < 0 {
				continue
			}
			if p.y < 0 {
				continue
			}
			if p.x+p.y == fk {
				return p
			}
		}
	}
	return Point{
		x: 0.0,
		y: 0.0,
	}
}
func absint(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

type Point struct {
	x, y float64
}

type Line struct {
	gradient, intercept float64
	constx, consty      bool
	x, y                float64
}

func (l *Line) init(p1, p2 Point) {
	dy := p2.y - p1.y
	dx := p2.x - p1.x
	if dx == 0 {
		l.constx = true
		l.x = p1.x
		return
	}
	if dy == 0 {
		l.consty = true
		l.y = p1.y
		return
	}
	l.gradient = dy / dx
	l.intercept = p1.y - p1.x*l.gradient
}

func (l *Line) isCross(target Line) bool {
	if l.constx {
		if target.constx {
			return false
		}
		if target.consty {
			return true
		}
	}
	if l.consty {
		if target.consty {
			return false
		}
		if target.constx {
			return true
		}
	}
	return l.gradient != target.gradient
}

func (l *Line) crossPoint(target Line) Point {
	var p Point

	if l.constx && target.consty {
		p.x = l.x
		p.y = target.y
		return p
	}
	if l.consty && target.constx {
		p.x = target.x
		p.y = l.y
		return p
	}
	p.x = -(l.intercept - target.intercept) / (l.gradient - target.gradient)
	p.y = p.x*l.gradient + l.intercept
	return p
}


Measured memory_bytes: 17792