#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <string>
#include <map>
#include <set>
#include <stack>
#include <tuple>
#include <deque>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cassert>
#include <chrono>
#include <random>
#include <limits>
#include <iterator>
#include <functional>
#include <sstream>
#include <complex>
using namespace std;

using ll = long long;
using ull = uint64_t;
using P = pair<int, int>;
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;

template<class T>
inline bool chmax(T& x, T y){
    if(x < y){
        x = y;
        return true;
    }
    return false;
}
template<class T>
inline bool chmin(T& x, T y){
    if(x > y){
        x = y;
        return true;
    }
    return false;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int K, X, Y;
    cin >> K >> X >> Y;
    if(K % 2 == 0 && (X + Y) % 2 != 0){
        cout << -1 << endl;
        return 0;
    }
    bool InversionX = false, InversionY = false;
    bool Exchange = false;
    if(X < 0){
        X = -X;
        InversionX = true;
    }
    if(Y < 0){
        Y = -Y;
        InversionY = true;
    }
    if(X < Y){
        swap(X, Y);
        Exchange = true;
    }

    vector<P> ans;
    int n;
    int x = 0, y = 0;
    if(X + Y < K){
        if((X + Y) % 2){
            n = 3;
            x += X, y -= K - X;
            ans.emplace_back(x, y);
            x += (K + X - Y) / 2, y += (K - X + Y) / 2;
            ans.emplace_back(x, y);
            x -= (K + X - Y) / 2, y += (K - X + Y) / 2;
            ans.emplace_back(x, y);
        }
        else{
            n = 2;
            x += (X + Y) / 2, y -= K - (X + Y) / 2;
            ans.emplace_back(x, y);
            x += (X - Y) / 2, y += (K * 2 - X + Y) / 2;
            ans.emplace_back(x, y);
        }
    }
    else{
        int c = (K - (X + Y) % K) % K;
        n = (X + Y + K - 1) / K;
        if(c % 2){
            ++n;
            int bound = (K * n - X - Y) / 2;
            while(y - K >= bound){
                y -= K;
                ans.emplace_back(x, y);
            }
            bound = -bound;
            int dif = y - bound;
            if(dif != 0){
                x += K - dif, y -= dif;
                ans.emplace_back(x, y);
            }
            while(x + K <= X){
                x += K;
                ans.emplace_back(x, y);
            }
            dif = X - x;
            if(dif != 0){
                x += dif, y += K - dif;
                ans.emplace_back(x, y);
            }
            while(y + K <= Y){
                y += K;
                ans.emplace_back(x, y);
            }
        }
        else{
            int bound = (K * n - X - Y) / 2;
            while(y - K >= bound){
                y -= K;
                ans.emplace_back(x, y);
            }
            bound = -bound;
            int dif = y - bound;
            if(dif != 0){
                x += K - dif, y -= dif;
                ans.emplace_back(x, y);
            }
            while(x + K <= X){
                x += K;
                ans.emplace_back(x, y);
            }
            dif = X - x;
            if(dif != 0){
                x += dif, y += K - dif;
                ans.emplace_back(x, y);
            }
            while(y + K <= Y){
                y += K;
                ans.emplace_back(x, y);
            }
        }
    }

    cout << n << '\n';
    for(int i = 0; i < n; ++i){
        if(Exchange)    swap(ans[i].first, ans[i].second);
        if(InversionX)  ans[i].first *= -1;
        if(InversionY)  ans[i].second *= -1;
        cout << ans[i].first << ' ' << ans[i].second << '\n';
    }
}

Measured memory_bytes: 5148