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;

typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}


typedef double D;
const D PI = acos(-1.0);
const D EPS = 1e-10;
struct P {
  D x, y;
  P(D x=0, D y=0) : x(x), y(y) {}

  P& operator+=(const P& o) { x += o.x; y += o.y; return *this; }
  P& operator-=(const P& o) { x -= o.x; y -= o.y; return *this; }
  P& operator*=(const P& o) { return *this = {x*o.x - y*o.y, x*o.y + y*o.x}; }
  P& operator*=(const D& r) { x *= r; y *= r; return *this; }
  P& operator/=(const D& r) { x /= r; y /= r; return *this; }
  P operator-() const { return {-x, -y}; }

  D norm() const { return x*x + y*y; }
  D abs() const { return sqrt(norm()); }
  D arg() const { return atan2(y, x); }
  bool isZero() const { return std::abs(x) < EPS && std::abs(y) < EPS; }
  /** 象限 */
  int orth() const { return y >= 0 ? (x >= 0 ? 1 : 2) : (x < 0 ? 3 : 4); }
  static P polar(const D& rho, const D& theta = 0) { return {rho * cos(theta), rho * sin(theta)}; }
};
std::ostream &operator<<(std::ostream &os, P const &p) { return os << "(" << p.x << ", " << p.y << ")"; }
std::istream &operator>>(std::istream &is, P &p) { D a, b; is >> a >> b; p = P(a, b); return is; }
P operator+(const P& p, const P& q) { return P(p) += q; }
P operator-(const P& p, const P& q) { return P(p) -= q; }
P operator*(const P& p, const P& q) { return P(p) *= q; }
P operator*(const P& p, const D& r) { return P(p) *= r; }
P operator/(const P& p, const D& r) { return P(p) /= r; }
P operator*(const D& r, const P& p) { return P(p) *= r; }
P operator/(const D& r, const P& p) { return P(p) /= r; }
D crs(const P& a, const P& b){ return a.x*b.y - a.y*b.x; }
D dot(const P& a, const P& b){ return a.x*b.x + a.y*b.y; }
int signum(D x) {return x > EPS ? +1 : x < -EPS ? -1 : 0;}
bool operator<(const P& a, const P& b) {
  if (a.x != b.x) return a.x < b.x;
  return a.y < b.y;
}

/** ベクトルpをベクトルbに射影したベクトル */
P proj(const P& p, const P& b) {
  P t = b * dot(p, b);
  return t / b.norm();
}
/** 点pから直線abに引いた垂線の足となる点 */
P footOfLP(const P& a, const P& b, const P& p) {
  return a + proj(p-a, b-a);
}

double distLP(const P& a, const P& b, const P& c) {
  return abs(crs(b-a, c-a)) / (b-a).abs();
}

int ccw(const P& a, P b, P c) {
  // return signum(crs(b - a, c - a));
  b -= a; c -= a;
  if (crs(b, c) > 0)       return +1;       // counter clockwise
  if (crs(b, c) < 0)       return -1;       // clockwise
  if (dot(b, c) < 0)       return +2;       // c--a--b on line
  if (b.norm() < c.norm()) return -2;       // a--b--c on line
  return 0;
}

struct C : public P {
  D r;
  C() {}
  C(const P &p, D r):P(p),r(r){}
};


// 円cと点pの接点をvectorで返す
vector<P> contactCP(C c, P p){
  vector<P> ret;
  D dist2 = (p - c).norm();
  D r2 = c.r * c.r;
  if( abs( r2 - dist2 ) < EPS ){ // 点が円周上にある
    ret.push_back( p );
    return ret;
  }
  if( r2 > dist2 ){ //点が円の内部にある
    return ret;
  }
  P q1 = (p - c) * ( r2 / dist2 );
  P q2 = (p - c) * P(0, 1) * (c.r * sqrt(dist2 - r2) / dist2);
  ret.push_back(c + q1 + q2);
  ret.push_back(c + q1 - q2);
  return ret;
}

// 2円の共通接線
vector<P> contactCC(const C& c1, const C& c2){
  vector<P> res;
  if (abs(c1.r - c2.r) < EPS) { // 外接線が平行
    P dir = c2 - c1;
    dir = dir * c1.r / dir.abs() * P(0,1);
    res.push_back(c1 + dir);
    res.push_back(c2 + dir);
    res.push_back(c1 - dir);
    res.push_back(c2 - dir);
  } else {
    P p = (c1 * -c2.r + c2 * c1.r) / (c1.r - c2.r);
    vector<P> ps = contactCP(c1, p);
    vector<P> qs = contactCP(c2, p);
    for (int i = 0; i < (int)ps.size() && i < (int)qs.size(); i++) {
      res.push_back(ps[i]);
      res.push_back(qs[i]);
    }
  }
  //内接線
  P p = (c1 * c2.r + c2 * c1.r) / (c1.r + c2.r);
  vector<P> ps = contactCP(c1, p);
  vector<P> qs = contactCP(c2, p);
  for (int i = 0; i < (int)ps.size() && i < (int)qs.size(); i++) {
    res.push_back(ps[i]);
    res.push_back(qs[i]);
  }
  return res;
}


int main2() {
  P p1, p2;
  double r1, r2;
  cin >> p1 >> r1;
  cin >> p2 >> r2;
  C c1 = C(p1, r1);
  C c2 = C(p2, r2);
  vector<P> ps = contactCC(c1, c2);

  vector<vector<P> > ls;
  for (int i = 0; i < (int)ps.size(); i += 2) {
    vector<P> l;
    l.push_back(ps[i]);
    l.push_back(ps[i+1]);
    ls.push_back(l);
  }
  sort(ALL(ls));

  for (vector<P> l : ls) {
    printf("%.10f %.10f\n", l[0].x, l[0].y);
  }
  return 0;
}

int main() {

#ifdef LOCAL
  for (;!cin.eof();cin>>ws)
#endif
    main2();
  return 0;
}