#include <bits/stdc++.h>

#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)

#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)

#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template<class T>void reg(vector<T> &ary,const T &elem){ary.emplace_back(elem);}
template<class T>bool chmin(T &a, const T &b) {return (b<a)?(a=b,1):0;}
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}

using R=long double; // __float128
const R EPS = 1E-8; // [-1000:1000]->EPS=1e-8 [-10000:10000]->EPS=1e-7
const R INF = 1E40;
constexpr R PI = acos(R(-1));
inline int sgn(const R& r){ return (r > EPS) - (r < -EPS);}
inline int sgn(const R& a, const R &b){ return sgn(a-b); }
inline R sq(R x){return sqrt(max<R>(x,0.0));}

using P=complex<R>;
using VP=vector<P>;
using L=struct{P s,t;};
using VL=vector<L>;
using C=struct{P c;R r;};
using VC=vector<C>;

constexpr P O = P(0,0);
istream& operator >> (istream& is,P& p){ R x,y;is >> x >> y; p=P(x,y); return is;}
ostream& operator << (ostream& os,P& p){ os << real(p) << " " << imag(p); return os;}

namespace std{
	bool operator <  (const P& a,const P& b){ return sgn(real(a-b))?real(a-b)<0:sgn(imag(a-b))<0;}
	bool operator == (const P& a,const P& b){ return sgn(real(a-b))==0 && sgn(imag(a-b))==0;}
}


inline R dot(P o,P a,P b){a-=o,b-=o; return real(conj(a)*b);}
inline R det(P o,P a,P b){a-=o,b-=o; return imag(conj(a)*b);}

P proj(P o,P a,P b){ a-=o,b-=o; return a*real(b/a);}
P proj(L l,P p){l.t-=l.s,p-=l.s;return l.s+l.t*real(p/l.t);}
P refl(L l,P p){ return R(2.0)*proj(l,p)-p;}

enum CCW{ LEFT = 1,RIGHT = 2,BACK = 4,FRONT = 8,ON = 16};
inline int ccw(P o,P a, P b) {
	if (sgn(det(o,a,b)) > 0) return LEFT;
	if (sgn(det(o,a,b)) < 0) return RIGHT;
	if (sgn(dot(o,a,b)) < 0) return BACK;
	if (sgn(norm(a-o)-norm(b-o)) < 0) return FRONT;
	return ON;
}


enum RCC{OUT=1,ON_OUT=2,ISC=4,ON_IN=8,IN=16,ONS=10};
int rcc(C a,C b){ R d=abs(a.c-b.c);return bit(2+sgn(a.r+b.r-d)+sgn(abs(a.r-b.r)-d));}


P cir(C c,R t){return c.c+polar(c.r,t);}
VP pcl(C c, L l){P h=proj(l,c.c),e=(l.t-l.s)/abs(l.t-l.s)*sq(norm(c.r)-norm(h-c.c));return VP{h-e,h+e};}
VP pcc(C a,C b){P d=b.c-a.c,w=(norm(d)+norm(a.r)-norm(b.r))/(2.0*norm(d))*d,h=a.c+w,e=w*P(0,1);return pcl(a,{h-e,h+e});}

L tan(C c,R t){P p=cir(c,t),d=(p-c.c)*P(0,1);return L{p-d,p+d};}

VL tan(C c,P p){
	VL res;R t=arg(p-c.c),e=acos(c.r/abs(p-c.c));
	reg(res,tan(c,t+e));
	if(sgn(e)) reg(res,tan(c,t-e));			
	return res;
}

VL tan(C a,C b){
	VL res;R t=arg(b.c-a.c),d=abs(b.c-a.c);int r=rcc(a,b);
	if(r<=ON_OUT){
		R p=acos((a.r+b.r)/d); // inner tangenet
		reg(res,tan(a,t+p));
		if(sgn(p)) reg(res,tan(a,t-p));
	}
	if(r<=ON_IN){
		R p=acos((a.r-b.r)/d); // outer tangent
		reg(res,tan(a,t+p));
		if(sgn(p)) reg(res,tan(a,t-p));
	}
	return res;
}

VP tan_test(C a,C b){
	VP res;R t=arg(b.c-a.c),d=abs(b.c-a.c);int r=rcc(a,b);
	if(r<=ON_OUT){
		R p=acos((a.r+b.r)/d); // inner tangenet
		reg(res,cir(a,t+p));
		if(sgn(p)) reg(res,cir(a,t-p));
	}
	if(r<=ON_IN){
		R p=acos((a.r-b.r)/d); // outer tangent
		reg(res,cir(a,t+p));
		if(sgn(p)) reg(res,cir(a,t-p));
	}
	return res;
}

int main(void){
	C c1,c2;
	cin >> c1.c >> c1.r >> c2.c >> c2.r;
		
	VP res=tan_test(c1,c2);
	uniq(res);
	cout.precision(20);
	for(auto &p:res) cout << fixed << p << endl;
	return 0;
}

Measured memory_bytes: 3604