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>
#define cmin(a,b) (a>(b)?a=(b),1:0)
#define cmax(a,b) (a<(b)?a=(b),1:0)
#define dmin(a,b) ((a)<(b)?(a):(b))
#define dmax(a,b) ((a)>(b)?(a):(b))
namespace io
{
	int F()
	{
		 int F=1,n=0;
		 char ch;
		 while((ch=getchar())!='-'&&(ch<'0'||ch>'9'));
		 ch=='-'?F=0:n=ch-'0';
		 while((ch=getchar())>='0'&&ch<='9')n=n*10+ch-'0';
		 return F?n:-n;
	}
	long long G()
	{
		 long long F=1,n=0;
		 char ch;
		 while((ch=getchar())!='-'&&(ch<'0'||ch>'9'));
		 ch=='-'?F=0:n=ch-'0';
		 while((ch=getchar())>='0'&&ch<='9')n=n*10+ch-'0';
		 return F?n:-n;
	}
}
namespace Geometry
{
	typedef double Scalar;
	
	Scalar Abs(Scalar x) {
		return x > 0 ? x : -x;
	}
	
	const Scalar eps = 1e-12;
	
	const double pi = acos(-1);
	
	struct Point;
	typedef Point Vector;
	
	struct Point
	{
		Scalar x,y;
		Scalar len() const {
			return sqrt(x*x + y*y);
		}
		Scalar len2() const {
			return x * x + y * y;
		}
        Vector uni() const {
            Scalar l = len();
            return l ? (Vector){x / l, y / l} : (Vector){0, 0};
        }
		Point operator + (const Vector &b) const {
			return (Point){x + b.x, y + b.y};
		}
		Vector operator - (const Point &b) const {
			return (Vector){x - b.x, y - b.y};
		}
		Point rotate(double ang) const {
			return (Point){x * cos(ang) - y * sin(ang), x * sin(ang) + y * cos(ang)};
		}
		Point rotate(const Point &o, double ang) const {
			return (*this - o).rotate(ang) + o;
		}
		void print() {
			printf("(%.3lf,%.3lf)\n",(double)x,(double)y);
		}
	};
	
	bool operator == (const Point &x, const Point &y) {
		return Abs(x.x - y.x) <= eps && Abs(x.y - y.y) <= eps;
	}
	Scalar operator * (const Vector &x, const Vector &y) {
		return x.x * y.y - x.y * y.x;
	}
	Scalar operator / (const Vector &x, const Vector &y) {
		return x.x * y.x + x.y * y.y;
	}
	Vector operator * (const Scalar &x, const Vector &y) {
		return (Vector){x * y.x, x * y.y};
	}
	Vector operator * (const Vector &y, const Scalar &x) {
		return (Vector){x * y.x, x * y.y};
	}
	Vector operator / (const Vector &x, const Scalar &y) {
		return (Vector){x.x / y, x.y / y};
	}
	
	struct Line
	{
		Point o;
		Vector l; // unit length
	};
	
	Scalar dist(const Point &x, const Line &y) { //signed
		return y.l * (x - y.o);
	}
	
	Point footpoint(const Point &x, const Line &y) {
		Scalar d=dist(x,y);
		return x - d * y.l.rotate(pi / 2);
	}
	
	Point intersect(const Line &x, const Line &y) {
		Scalar d1 = dist(x.o, y);
		Scalar d2 = dist(x.o + x.l, y);
		return x.o + d1 / (d1 - d2) * x.l;
	}
	
	struct Seg
	{
		Point x,y;
		Scalar len() const {
			return (x - y).len();
		}
	};
	
	Line line(const Seg &x) {
		return (Line){x.x, (x.y - x.x) / x.len()};
	}
	
	Scalar dist(const Point &o, const Seg &l) {
		if(Abs((l.y - l.x) * (o - l.x)) <= eps)
		{
			Scalar d1 = (o - l.x).len();
			Scalar d2 = (o - l.y).len();
			return (Abs(d1 + d2 - l.len()) <= eps) ? 0 : std::min(d1, d2);
		}
		else
		{
			if((l.y - l.x) / (o - l.x) < 0) return (o - l.x).len();
			if((l.x - l.y) / (o - l.y) < 0) return (o - l.y).len();
			return dist(o, line(l));
		} 
	}
	
	int convexHull(Point *p, int n, Point *s) { // return # of points on the convex hull + 1
		std::sort(p + 1, p + n + 1, [](const Point &x, const Point &y)  { return x.x != y.x ? x.x < y.x : x.y < y.y;});
		int ts;
		for(int i = 1; i <= n; ++i)
			if(i == 1 || !(p[i] == p[i-1]))
			{
				while(ts > 1 && (p[i] - s[ts-1]) * (s[ts] - s[ts-1]) <= 0)
					--ts;
				s[++ts] = p[i];
			}
		int cl = ts;
		for(int i = n - 1; i; ++i)
			if(!(p[i] == p[i+1]))
			{
				while(ts > cl && (p[i] - s[ts-1]) * (s[ts] - s[ts-1]) <= 0)
					--ts;
				s[++ts] = p[i];
			}
		return ts;
	}
	
	struct Circle
	{
		Point o;
		Scalar r;
		bool in(const Circle &y) const {
			return (o - y.o).len() + r <= y.r - eps;
		}
	};
	
	std::pair<Point, Point> intersect(const Circle &c, const Line &l) {
		Point p = footpoint(c.o, l);
		Scalar k = c.r * c.r - (c.o - p).len2();
		k = k < 0 ? 0 : sqrt(k);
		return std::make_pair(p + k * l.l, p - k * l.l);
	}
	
	std::pair<Point, Point> intersect(const Circle &x, const Circle &y) {
		Scalar d = (x.o - y.o).len();
		double ang = acos((x.r * x.r + d * d - y.r * y.r)/(2 * x.r * d));
		Vector v = x.r * (y.o - x.o) / d;
		return std::make_pair(x.o + v.rotate(ang), x.o + v.rotate(-ang));
	}
	
	std::pair<Line, Line> tangentLine(const Point &x, const Circle &c) {
		if(Abs((x - c.o).len() - c.r) <= eps) {
			Line l = (Line){x, (x - c.o).uni().rotate(pi/2)};
			return std::make_pair(l,l);
		}
		Scalar d1 = (c.o - x).len();
		double ang = asin(c.r / d1);
		Vector v = (c.o - x).uni();
		return std::make_pair((Line){x, v.rotate(ang)}, (Line){x, v.rotate(-ang)});
	}
	
	std::pair<Point, Point> tangentPoint(const Point &x, const Circle &c) {
		auto tl = tangentLine(x, c);
		Scalar d1 = (c.o - x).len();
		double ang = asin(c.r / d1);
		Scalar d2 = d1 * cos(ang);
		return std::make_pair(x + d2 * tl.first.l, x + d2 * tl.second.l);
	}
	
	std::pair<Seg, Seg> outerTSeg(Circle x, Circle y) {
		int sw=0;
		if(x.r > y.r)std::swap(x, y),sw=1;
		if(Abs(x.r + (x.o - y.o).len() - y.r) < eps)
		{
			auto s = intersect(x, y).first;
			return std::make_pair((Seg){s, s}, (Seg){s, s});
		}
		y.r -= x.r;
		auto p = tangentPoint(x.o, y);
		auto q = tangentLine(x.o, y);
		Vector b1 = q.first.l.rotate(pi/2) * x.r;
		Vector b2 = q.second.l.rotate(-pi/2) * x.r;
		auto ret = std::make_pair((Seg){x.o + b1, p.first + b1}, (Seg){x.o + b2, p.second + b2});
		if(sw) std::swap(ret.first.x, ret.first.y), std::swap(ret.second.x, ret.second.y);
		return ret;
	}
	
	std::pair<Seg, Seg> innerTSeg(const Circle &x, Circle y) {
		if(Abs((x.o - y.o).len() - x.r - y.r) < eps)
		{
			auto s = intersect(x, y).first;
			return std::make_pair((Seg){s, s}, (Seg){s, s});
		}
		y.r += x.r;
		auto p = tangentPoint(x.o, y);
		Vector b1 = (p.first - y.o).uni() * x.r;
		Vector b2 = (p.second - y.o).uni() * x.r;
		return std::make_pair((Seg){x.o - b1, p.first - b1}, (Seg){x.o - b2, p.second - b2});
	}
	bool operator <(const Point &x,const Point &y)
	{
	    if(fabs(x.x-y.x)>eps)return x.x<y.x;
	    return x.y<y.y;
	}
}
int main()
{
    int cx=io::F(),cy=io::F(),r=io::F();
    using namespace Geometry;
    Circle c={{(double)cx,(double)cy},(double)r};
    cx=io::F(),cy=io::F(),r=io::F();
    Circle d={{(double)cx,(double)cy},(double)r};
    std::vector<Point> a;
    if(!c.in(d)&&!d.in(c))
    {
    	auto s=outerTSeg(c,d);
    	a.push_back(s.first.x);
    	a.push_back(s.second.x);
    }
    if(c.r+d.r<=(c.o-d.o).len()+eps)
    {
    	auto s=innerTSeg(c,d);
    	a.push_back(s.first.x);
    	a.push_back(s.second.x);
    }
    std::sort(a.begin(),a.end());
    auto pp=std::unique(a.begin(),a.end());
    for(auto i=a.begin();i!=pp;++i)
    	printf("%.9lf %.9lf\n",i->x,i->y);
	return 0;
}