#include <bits/stdc++.h>
using namespace std;

using ll=long long;
#define int ll
using uint=unsigned;
using ull=unsigned ll;

#define rng(i, a, b) for(int i=(int)a;i<(int)b;i++)
#define rep(i,n) rng(i,0,n)
using ld=long double;
const ld eps=1e-9;
bool is0(ld x){ return -eps<=x&&x<=eps; }
template<class t>using vc=vector<t>;
template<class t>using vvc=vc<vc<t>>;
using vi=vc<int>;
#define a first
#define b second
using vi=vc<int>;
#define pb push_back
#define eb emplace_back
template<class t,class u>bool chmax(t &a,u b){
	if(a <b){a=b;return true;}
	else return false;
}

#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
#define si(x) int(x.size())

template<class t>void mkuni(vc<t>&vs){
	sort(all(vs));
	vs.erase(unique(all(vs)),vs.ed);
}
template<class t>int lwb(const vc<t>&vs,t a){
	return lower_bound(all(vs),a)-vs.bg;
}

const uint mod=1000000007;

struct mint{
	uint v;
	mint(ll vv=0){s(vv%mod+mod);}
	mint&s(uint vv){
		v=vv<mod?vv:vv-mod;
		return *this;
	}
	mint operator-()const{return mint()-*this;}
	mint&operator+=(const mint&r){return s(v+r.v);}
	mint&operator-=(const mint&r){return s(v+mod-r.v);}
	mint&operator*=(const mint&r){v=(ull)v*r.v%mod;return *this;}
	mint&operator/=(const mint&r){return *this*=r.inv();}
	mint operator+(const mint&r)const{return mint(*this)+=r;}
	mint operator-(const mint&r)const{return mint(*this)-=r;}
	mint operator*(const mint&r)const{return mint(*this)*=r;}
	mint operator/(const mint&r)const{return mint(*this)/=r;}
	mint pow(ll n)const{
		if(n<0)return inv().pow(-n);
		mint res(1),x(*this);
		while(n){
			if(n&1)res*=x;
			x*=x;
			n>>=1;
		}
		return res;
	}
	mint inv()const{return pow(mod-2);}
	bool operator<(const mint&r)const{return v<r.v;}
	bool operator==(const mint&r)const{return v==r.v;}
};

using pt=complex<ld>;
#define x real()
#define y imag()

ld dist(pt a,pt b){
	return sqrt(norm(a-b));
}

int sgn(ld a){return a<-eps?-1:(a>eps?1:0);}
int sgn(ld a,ld b){return sgn(a-b);}

void slv(){
	int n,m;cin>>n>>m;
	ld tar;cin>>tar;
	
	vc<pt> ls;
	ls.eb(0,0);
	int i=0,j=0;
	rep(step,100000){
		if(step%4==0){
			j=m;
		}else if(step%4==1){
			i++;
		}else if(step%4==2){
			j=0;
		}else{
			i++;
		}
		pt cur=ls.back();
		pt nx=pt(i,j);
		
		auto calc=[&](ld t){
			pt z=cur*(1-t)+nx*t;
			return dist(cur,z)+dist(z,pt(n,m));
		};
		
		if(sgn(tar,calc(1))<=0){
			ld lw=0,up=1;
			rep(_,60){
				const ld mid=(lw+up)/2;
				if(sgn(tar,calc(mid))<=0)up=mid;
				else lw=mid;
			}
			ls.pb(cur*(1-up)+nx*up);
			ls.eb(n,m);
			break;
		}else{
			tar-=dist(cur,nx);
			ls.pb(nx);
		}
	}
	
	cout<<si(ls)<<endl;
	for(auto v:ls){
		cout<<v.x<<" "<<v.y<<endl;
	}
	if(0){
		ld sum=0;
		rep(k,si(ls)-1)sum+=dist(ls[k],ls[k+1]);
		cerr<<sum<<endl;
	}
}

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);
	
	slv();
}