#include "bits/stdc++.h"

#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9

constexpr int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
constexpr int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};

using namespace std;

using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

template <class T> bool chmin(T &a, const T &b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> bool chmax(T &a, const T &b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
using ld = long double;
using Point = std::complex<ld>;

const ld eps = 1e-9, pi = acos(-1.0);

namespace std {
bool operator<(const Point &lhs, const Point &rhs) {
	if (lhs.real() < rhs.real() - eps) return true;
	if (lhs.real() > rhs.real() + eps) return false;
	return lhs.imag() < rhs.imag();
}
} // namespace std

Point input_point() {
	ld x, y;
	std::cin >> x >> y;
	return Point(x, y);
}

bool eq(ld a, ld b) {
	return (abs(a - b) < eps);
}

ld dot(Point a, Point b) {
	return real(conj(a) * b);
}

ld cross(Point a, Point b) {
	return imag(conj(a) * b);
}

// CCW::counter clockwise
int ccw(Point a, Point b, Point c) {
	b -= a;
	c -= a;
	if (cross(b, c) > eps) return 1;   // a,b,c : counter-clockwise
	if (cross(b, c) < -eps) return -1; // a,b,c : clockwise
	if (dot(b, c) < 0) return 2;       // c,a,b : on a line
	if (norm(b) < norm(c)) return -2;  // a,b,c : on a line
	return 0;                          // a,c,b : on a line
}

class Line {
  public:
	Point a, b;
	Line() : a(Point(0, 0)), b(Point(0, 0)) {}
	Line(Point a, Point b) : a(a), b(b) {}
};

ld dot(Line l, Line m) {
	return dot((l.a - l.b), (m.a - m.b));
}

// l:line, m:line が交点を持つか
bool isis_ll(Line l, Line m) {
	return !eq(cross(l.b - l.a, m.b - m.a), 0);
}

// l:line, s:segment
bool isis_ls(Line l, Line s) {
	return isis_ll(l, s) &&
	       (cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}

// s:segment, t:segment
bool isis_ss(Line s, Line t) {
	return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
	       ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}

// p が l:line 上に存在するか
bool isis_lp(Line l, Point p) {
	return (abs(cross(l.b - p, l.a - p)) < eps);
}

bool isis_sp(Line s, Point p) {
	return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}

// p から l に下ろした足との交点
Point proj(Line l, Point p) {
	ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
	return l.a + t * (l.a - l.b);
}

// l:line, t:line の交点
Point is_ll(Line l, Line m) {
	Point lv = l.b - l.a, mv = m.b - m.a;
	if (cross(lv, mv) == 0) {
		return {-INF, -INF};
	}
	return l.a + lv * cross(mv, m.a - l.a) / cross(mv, lv);
}

// p, l:line の距離
ld dist_lp(Line l, Point p) {
	return abs(p - proj(l, p));
}

ld dist_ll(Line l, Line m) {
	return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}

ld dist_ls(Line l, Line s) {
	return isis_ls(l, s) ? 0 : std::min(dist_lp(l, s.a), dist_lp(l, s.b));
}

ld dist_sp(Line s, Point p) {
	Point r = proj(s, p);
	return isis_sp(s, r) ? abs(r - p) : std::min(abs(s.a - p), abs(s.b - p));
}

ld dist_ss(Line s, Line t) {
	if (isis_ss(s, t)) return 0;
	return std::min(
	    {dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b)});
}

// a, b の垂直二等分線. a -> b を90度反時計回り回転
Line bisector(Point a, Point b) {
	Point mid = (a + b) * Point(0.5, 0);
	return Line(mid, mid + (b - a) * Point(0, pi / 2));
}

// 直線 l, m のなす角を求める
ld degree_ll(Line l, Line m) {
	ld cos_shita = dot(l, m) / (abs(l.b - l.a) * abs(m.b - m.a));
	if (cos_shita < -1.0) cos_shita = -1.0;
	if (cos_shita > 1.0) cos_shita = 1.0;
	ld shita = acos(cos_shita);
	// shita = sita * 180.0 / PI;
	return shita;
}
int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	int k;
	cin >> k;
	int x, y;
	cin >> x >> y;
	if (k % 2 == 0 && (abs(x) + abs(y)) % 2 == 1) {
		cout << -1 << endl;
		return 0;
	}
	int sx = 0, sy = 0;
	vector<pii> ans;
	while (abs(x - sx) + abs(y - sy) > 2 * k) {
		if (abs(x - sx) > k) {
			if (x > sx)
				sx += k;
			else
				sx -= k;
		} else {
			if (y > sy)
				sy += k;
			else
				sy -= k;
		}
		ans.push_back({sx, sy});
	}
	auto solve = [&](int sx, int sy) {
		vector<Line> a, b;
		a.push_back({{x, y + k}, {x + k, y}});
		a.push_back({{x + k, y}, {x, y - k}});
		a.push_back({{x, y - k}, {x - k, y}});
		a.push_back({{x - k, y}, {x, y + k}});

		b.push_back({{sx, sy + k}, {sx + k, sy}});
		b.push_back({{sx + k, sy}, {sx, sy - k}});
		b.push_back({{sx, sy - k}, {sx - k, sy}});
		b.push_back({{sx - k, sy}, {sx, sy + k}});

		REP(i, 4) REP(j, 4) {

			if (!isis_ss(a[i], b[j])) continue;
			auto p = is_ll(a[i], b[j]);
			if (abs(p.real() + INF) < EPS) {
				REP(c, 4) {
					auto po = a[i].a;
					int tx = po.real(), ty = po.imag();
					if (abs(tx - sx) + abs(ty - sy) == k) {
						return pii(tx, ty);
					}
				}
				REP(c, 4) {
					auto po = b[i].a;
					int tx = po.real(), ty = po.imag();
					if (abs(tx - x) + abs(ty - y) == k) {
						return pii(tx, ty);
					}
				}
			} else {
				int tx = p.real(), ty = p.imag();
				if (abs(tx - p.real()) < EPS && abs(ty - p.imag()) < EPS) {
					return pii(tx, ty);
				}
			}
		}
		return pii(-2 * INF, -2 * INF);
	};
	if (abs(x - sx) + abs(y - sy) == k) {
		ans.push_back({x, y});
	} else if ((abs(x - sx) + abs(y - sy)) % 2 == 1) {
		if (abs(x - sx) >= k) {
			if (x > sx)
				sx += k;
			else
				sx -= k;
		} else if (abs(y - sy) >= k) {
			if (y > sy)
				sy += k;
			else
				sy -= k;
		} else {
			if (x >= sx)
				sx += k;
			else
				sx -= k;
		}
		ans.push_back({sx, sy});
		pii p = solve(sx, sy);
		ans.push_back(p);
		ans.push_back({x, y});
	} else {
		pii p = solve(sx, sy);
		ans.push_back(p);
		ans.push_back({x, y});
	}
	cout << ans.size() << endl;
	REP(i, ans.size()) cout << ans[i].first << " " << ans[i].second << endl;
}

Measured memory_bytes: 3824