#include "bits/stdc++.h"
#define rep(i, a, n) for(auto i = a; i <= (n); i++)
#define per(i, a, n) for(auto i = n; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if(a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if(b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(pair<A, B> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A> string to_string(A v)
{
    bool first = 1;
    string res = "{";
    for(const auto &x: v) 
    {
        if (!first) res += ", ";
        first = 0;
        res += to_string(x);
    }
    res += "}";
    return res;
}
template<class A, class B> string to_string(pair<A, B> p) { return "(" + to_string(p.FI) + ", " + to_string(p.SE) + ")"; }

void debug_out() { cerr << endl; }
template<class Head, class... Tail> void debug_out(Head H, Tail... T) 
{
    cerr << " " << to_string(H);
    debug_out(T...);
}
#ifndef ONLINE_JUDGE
    #define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
    #define debug(...) if(0) puts("No effect.")
#endif

using ll = long long;
// using LL = __int128;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using db = double;
using ldb = long double;

const int maxn = 1'000'000;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;


const db pi = acos(-1.0);

template<class T> struct TPoint
{   // use T = double or T = long long.
    using P = TPoint;
    static constexpr T eps = static_cast<T>(1e-9);
    static int sgn(T x) { return (x > eps) - (x < -eps); }
    static int cmp(T x, T y) { return sgn(x - y); }
    static T sqr(T x) { return x * x; }

    T x, y;

    P operator +(P a) const { return P{x + a.x, y + a.y}; }
    P operator -(P a) const { return P{x - a.x, y - a.y}; }
    P operator *(T a) const { return P{x * a, y * a}; }
    P operator /(T a) const { return P{x / a, y / a}; }
    bool operator ==(P a) const { return cmp(x, a.x) == 0 && cmp(y, a.y) == 0; }
    bool operator <(P a) const { return cmp(x, a.x) == 0 ? cmp(y, a.y) < 0: x < a.x; }
    T len() const { return sqrt(sqr(x) + sqr(y)); }
    T dis_to(P a) const { return (*this - a).len(); }
    T len2() const { return sqr(x) + sqr(y); }
    P unit() const { return *this / len(); }

    T dot(P b) const { return x * b.x + y * b.y; }
    T cross(P b) const { return x * b.y - y * b.x; }
    bool is_upper() const { return y > eps || (sgn(y) == 0 && x < -eps); }
    static bool cmp_polar(P a, P b)
    {
        if(a.is_upper() != b.is_upper()) return a.is_upper() < b.is_upper();
        return a.cross(b) > eps;
        // one issue of this function is that if you use float-type and the values have large range then colinear points might be viewed as non-colinear.
    }
    P rot90() { return P{-y, x}; }

    // the following only work for double
    P rotate(db theta) const
    {
        P a{cos(theta), sin(theta)};
        return P{x * a.x - y * a.y, x * a.y + y * a.x};
    }
    T project_len(P a, P b) const { return (*this - a).dot((b - a).unit()); } // signed.
    T dis_to_line(P a, P b) const { return (*this - a).cross((b - a).unit()); } // signed.
    T dis_to_seg(P a, P b) const
    {
        if(project_len(a, b) < -eps) return (*this - a).len();
        if(project_len(b, a) < -eps) return (*this - b).len();
        return fabs(dis_to_line(a, b));
    }
    P project_to_line(P a, P b) const { return a + (b - a) * project_len(a, b); }
    bool on_seg(P a, P b) const { return dis_to_seg(a, b) <= eps; } // including vertice a and b.
    bool on_line(P a, P b) const { return sgn(dis_to_line(a, b)) == 0; }
};
using P = TPoint<db>;
using vp = vector<P>;

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

    int n, m; db L;
    cin >> n >> m >> L;
    auto cal = [&](const vp &A)
    {
        db res = 0;
        rep(i, 0, sz(A) - 2) res += (A[i] - A[i + 1]).len();
        return res;
    };
    if(L <= n + m)
    {
        P md{n / 2.0, m / 2.0}, cor{n, 0};
        auto get = [&](db rat) { return vp{P{0, 0}, md + (cor - md) * rat, P{n, m}}; };
        db l = 0.0, r = 1.0;
        rep(_, 1, 60) 
        {
            db mid = (l + r) / 2.0;
            if(cal(get(mid)) >= L) r = mid;
            else l = mid;
        }
        vp ans = get(r);
        printf("%d\n", sz(ans));
        for(auto [x, y]: ans) printf("%.9f %.9f\n", x, y);
    }
    else
    {
        auto get = [&](db rat)
        {
            vp res{P{0, 0}};
            rep(i, 0, m - 1) 
            {
                if(i & 1) res.pb(P{n * (1 - rat), i});
                else res.pb(P{n, i});
            }
            res.pb(P{n, m});
            return res;
        };
        db l = 0.0, r = 1.0;
        rep(_, 1, 60) 
        {
            db mid = (l + r) / 2.0;
            if(cal(get(mid)) >= L) r = mid;
            else l = mid;
        }
        vp ans = get(r);
        printf("%d\n", sz(ans));
        for(auto [x, y]: ans) printf("%.9f %.9f\n", x, y);
    }
    return 0;
}