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>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;



struct Point{
    Point(double arg_x,double arg_y){
        x = arg_x;
        y = arg_y;
    }

    Point(){
        x = y = 0.0;
    }

    Point operator + (Point p){ return Point(x+p.x,y+p.y); }
    Point operator - (Point p){ return Point(x-p.x,y-p.y);}
    Point operator * (double a){ return Point(a*x,a*y); }
    Point operator / (double a){ return Point(x/a,y/a); }

    double abs(){ return sqrt(norm()); }
    double norm(){ return x*x + y*y; }

    bool operator<(const Point &p) const{
        return x != p.x? x < p.x: y < p.y;
    }

    bool operator == (const Point &p) const{
        return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
    }

    double x,y;
};

typedef Point Vector;

struct Sphere{
    Point center;
    double r;
};

typedef Sphere Circle;

struct Line{
public:
    Point p[2];
    Line(Point p1,Point p2){
        p[0] = p1;
        p[1] = p2;
    }
    Line(){

    }
};

double NUM = 10000;

double norm(Vector a){
    return a.x*a.x+a.y*a.y;
}

double abs(Vector a){
    return sqrt(norm(a));
}

double cross(Vector a,Vector b){
    return a.x*b.y-a.y*b.x;
}

double dot(Vector a,Vector b){
    return a.x*b.x + a.y*b.y;
}

Point calc_minus(Point a,Point b){
    Point ret;

    ret.x = a.x-b.x;
    ret.y = a.y-b.y;

    return ret;
}

double calc_len(Vector a){
    return sqrt(a.x*a.x+a.y*a.y);
}

double getDistanceLP(Line l,Point p){
    return fabs(cross(calc_minus(l.p[1],l.p[0]),calc_minus(p,l.p[0]))/calc_len(calc_minus(l.p[1],l.p[0])));
}

Point project(Line l,Point p){

    Vector base = l.p[1]-l.p[0];
    double r = dot(p-l.p[0],base)/norm(base);
    return l.p[0]+base*r;
}

//円と直線の交点を求める関数
vector<Point> getCrossPoints(Circle c,Line l){

    vector<Point> ret;

    Vector pr = project(l,c.center);
    Vector e = (l.p[1]-l.p[0])/abs(l.p[1]-l.p[0]);

    double base;

    if(fabs(c.r*c.r-norm(pr-c.center)) < EPS){

        base = 0;
    }else{
        base = sqrt(c.r*c.r-norm(pr-c.center));
    }

    ret.push_back(Point(pr+e*base));
    ret.push_back(Point(pr-e*base));

    return ret;
}


/*http://hg.hatenablog.jp/entry/2016/02/08/210906
 * を参考にさせていただきました
 * */
vector<Point> getContact(Circle C1,Circle C2){

	vector<Point> ret;

	double p = C2.center.x-C1.center.x;
	double q = C2.center.y-C1.center.y;

	double A = p*p+q*q;

	double n_1 = (q*C1.r*(C1.r+C2.r)-p*C1.r*sqrt(A-(C1.r+C2.r)*(C1.r+C2.r)))/(A)+C1.center.y;
	double n_2 = (q*C1.r*(C1.r+C2.r)+p*C1.r*sqrt(A-(C1.r+C2.r)*(C1.r+C2.r)))/(A)+C1.center.y;

	double m_1 = (p*C1.r*(C1.r+C2.r)+q*C1.r*sqrt(A-(C1.r+C2.r)*(C1.r+C2.r)))/(A)+C1.center.x;
	double m_2 = (p*C1.r*(C1.r+C2.r)-q*C1.r*sqrt(A-(C1.r+C2.r)*(C1.r+C2.r)))/(A)+C1.center.x;

	if(A-(C1.r+C2.r)*(C1.r+C2.r) >= 0){
		ret.push_back(Point(m_1,n_1));
		ret.push_back(Point(m_2,n_2));
	}

	double n_3 = (q*C1.r*(C1.r-C2.r)-p*C1.r*sqrt(A-(C1.r-C2.r)*(C1.r-C2.r)))/(A)+C1.center.y;
	double n_4 = (q*C1.r*(C1.r-C2.r)+p*C1.r*sqrt(A-(C1.r-C2.r)*(C1.r-C2.r)))/(A)+C1.center.y;

	double m_3 = (p*C1.r*(C1.r-C2.r)+q*C1.r*sqrt(A-(C1.r-C2.r)*(C1.r-C2.r)))/(A)+C1.center.x;
	double m_4 = (p*C1.r*(C1.r-C2.r)-q*C1.r*sqrt(A-(C1.r-C2.r)*(C1.r-C2.r)))/(A)+C1.center.x;

	if(A-(C1.r-C2.r)*(C1.r-C2.r) >= 0){
		ret.push_back(Point(m_3,n_3));
		ret.push_back(Point(m_4,n_4));
	}

	return ret;
}


int calc_num(Circle A,Circle B){

	double c1x,c1y,c1r,c2x,c2y,c2r,dist;

	c1x = A.center.x;
	c1y = A.center.y;

	c2x = B.center.x;
	c2y = B.center.y;

	dist = sqrt((c1x-c2x)*(c1x-c2x)+(c1y-c2y)*(c1y-c2y));

	if(dist > c1r + c2r){

		return 4;

	}else if(fabs(dist - (c1r+c2r)) < EPS){

		return 3;

	}else{
		if(c1r > c2r){
			if(dist < c1r){
				if(fabs(c1r-(dist+c2r)) < EPS){
					return 1;
				}else{
					if(dist < (c1r-c2r)){
						return 0;
					}else{
						return 2;
					}
				}

			}else{
				return 2;
			}

		}else{
			if(dist < c2r){
				if(fabs(c2r-(dist+c1r)) < EPS){
					return 1;
				}else{
					if(dist < (c2r-c1r)){
						return 0;
					}else{
						return 2;
					}
				}
			}else{
				return 2;
			}
		}
	}
}

int main(){

	Circle A,B;

	scanf("%lf %lf %lf",&A.center.x,&A.center.y,&A.r);
	scanf("%lf %lf %lf",&B.center.x,&B.center.y,&B.r);

	int num_line = calc_num(A,B);

	if(num_line == 0){

		printf("0\n");
		return 0;
	}

	vector<Point> ans = getContact(A,B);

	if(ans.size() == 0){

		return 0;
	}

	sort(ans.begin(),ans.end());

	printf("%.10lf %.10lf\n",ans[0].x,ans[0].y);

	for(int i = 1; i < ans.size(); i++){
		if(ans[i] == ans[i-1])continue;

		printf("%.10lf %.10lf\n",ans[i].x,ans[i].y);
	}

    return 0;
}