Problem: Find common tangent lines of two circles $c1$ and $c2$.

Constraints

* $-1,000 \leq c1x, c1y, c2x, c2y \leq 1,000$
* $1 \leq c1r, c2r \leq 1,000$
* $c1$ and $c2$ are different

Input

Center coordinates ($cix$, $ciy$) and radii $cir$ of two circles $c1$ are $c2$ are given in the following format.

$c1x \; c1y \; c1r$
$c2x \; c2y \; c2r$

All input values are given in integers.

Output

Print coordinates of the tangent points on circle $c1$ based on the following rules.

* Print the coordinate with smaller $x$ first. In case of a tie, print the coordinate with smaller $y$ first.



The output values should be in a decimal fraction with an error less than 0.00001.

Examples

Input

1 1 1
6 2 2


Output

0.6153846154 1.9230769231
1.0000000000 0.0000000000
1.4183420913 1.9082895434
1.7355040625 0.3224796874


Input

1 2 1
4 2 2


Output

0.6666666667 1.0571909584
0.6666666667 2.9428090416
2.0000000000 2.0000000000


Input

1 2 1
3 2 2


Output

0.5000000000 1.1339745962
0.5000000000 2.8660254038


Input

0 0 1
1 0 2


Output

-1.0000000000 0.0000000000


Input

0 0 1
0 0 2


Output

Solution (in CPP):

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

//point
typedef complex<double> P;
namespace std {
	bool operator < (const P& a, const P& b) {
		return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
	}
	bool cmp_y(const P &a, const P &b){
		return a.imag() != b.imag() ? a.imag() < b.imag() : a.real() < b.real();
	}
}
double cross(const P& a, const P& b) {
	return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
	return real(conj(a)*b);
}
P n_vector(P a){
  double l = abs(a);
  return P(-a.imag(), a.real())/l;
}

// line
struct L : public vector<P> {
	L(const P& a, const P& b) {
		push_back(a); push_back(b);
	}
};

P projection(const L &l, const P &p) {
	double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
	return l[0] + t*(l[0]-l[1]);
}
double distanceLP(const L &l, const P &p) {
	return abs(p - projection(l, p));
}

// circle
struct C {
	P p; double r;
	C(const P& p, double r) : p(p), r(r) {}
};

int intersectCC(const C& a, const C& b) {
	double dist = sqrt(norm(a.p-b.p)), r1 = a.r + b.r, r2 = abs(a.r - b.r);
	if(r1 < dist) return 4;		//??\?????????
	if(dist == r1) return 3;	//?????\
	if(r2 < dist && dist < r1) return 2; //?????????
	if(dist == r2) return 1; //?????\
	return 0;	//??????
}

vector<P> crossPointCL(C c, L l) {
	double d = distanceLP(l, c.p), r = c.r;
	P m = projection(l, c.p);
	P x = sqrt(r*r-d*d)/abs(l[1]-l[0])*(l[1]-l[0]);
	vector<P> ret(2,m);
	ret[0] -= x;
	ret[1] += x;
	sort(ret.begin(), ret.end());	//!!!
	return ret;
}

vector<P> crossPointCC(C a, C b) {
	double d = abs(a.p-b.p);
	double t = (a.r*a.r-b.r*b.r+d*d)/2/d, h = sqrt(a.r*a.r-t*t);
	P m = t/abs(b.p-a.p)*(b.p-a.p)+a.p;
	P n = n_vector(a.p-b.p);
	vector<P> ret(2, m);
	ret[0] -= h*n;
	ret[1] += h*n;
	sort(ret.begin(), ret.end());	//!!!
	return ret;
}	

vector<P> tangentLC(P p, C c) {
	C c2 = C((p+c.p)/2.0, abs(p-c.p)/2.0);
	return crossPointCC(c, c2);
}

vector<P> commonTangent(C a, C b) {
	vector<P> ret, cp;
	if(a.r == b.r) {
		P n = n_vector(b.p-a.p);
		ret.push_back(P{a.p+a.r*n});
		ret.push_back(P{a.p-a.r*n});
	}
	P i = (a.p*b.r+b.p*a.r)/(a.r+b.r);
  	if(abs(a.p-b.p) > a.r+b.r){
    	cp = tangentLC(i,a);
    	for(int i = 0; i < 2; ++i) ret.push_back(cp[i]);
    	if(a.r != b.r){
      		P e = (a.p*b.r-b.p*a.r)/(b.r-a.r);
      		cp = tangentLC(e,a);
      		for(int i = 0; i < 2; ++i) ret.push_back(cp[i]);
    	}
  	}else if(abs(a.p-b.p) == a.r+b.r){
    	cp = tangentLC(i,a);
    	ret.push_back(cp[0]);
    	if(a.r != b.r){
    		P e = (a.p*b.r-b.p*a.r)/(b.r-a.r);
      		cp = tangentLC(e,a);
      		for(int i = 0; i < 2; ++i) ret.push_back(cp[i]);
    	}
  	}else if(abs(a.p-b.p) > abs(a.r-b.r)){
    	if(a.r != b.r){
    		P e = (a.p*b.r-b.p*a.r)/(b.r-a.r);
      		cp = tangentLC(e,a);
      		for(int i = 0; i < 2; ++i) ret.push_back(cp[i]);
    	}
  	}else if(abs(a.p-b.p) == abs(a.r-b.r)){
    	P e = (a.p*b.r-b.p*a.r)/(b.r-a.r);
    	cp = tangentLC(e,a);
    	ret.push_back(cp[0]);
  	}
	sort(ret.begin(), ret.end());
  	return ret;
}

int main() {
	double x1, y1, r1, x2, y2, r2;
	cin >> x2 >> y2 >> r2 >> x1 >> y1 >> r1;
	C c2(P{x1, y1}, r1), c1(P{x2, y2}, r2);
	vector<P> ans =	commonTangent(c1, c2);
	for(int i=0; i<ans.size(); ++i) {
		cout << fixed << setprecision(15) << ans[i].real()+0 << " " << ans[i].imag()+0 << endl;
	}
}