#include <iostream>
#include <iomanip>
#include <math.h>
#include <vector>
#include <algorithm>

using namespace std;

const double eps = 1e-10;

class Point {
public:
    double x, y;
    Point(double _x = 0., double _y = 0.) : x(_x), y(_y) {}
};

istream& operator >> (istream& in, Point& P)
{
    in >> P.x >> P.y;
    return in;
}

ostream& operator << (ostream& out, const Point& P)
{
    out << P.x << " " << P.y;
    return out;
}

double Dist(const Point& P, const Point& Q)
{
    double dx = P.x - Q.x;
    double dy = P.y - Q.y;
    return sqrt(dx * dx + dy * dy);
}

class Circle {
public:
    Point c;
    double r;
    Circle(const Point& _c = Point(), double _r = 0.) : c(_c), r(_r) {}
};

istream& operator >> (istream& in, Circle& C)
{
    in >> C.c >> C.r;
    return in;
}

int CircStatus(const Circle& C1, const Circle& C2)
{
    double d = Dist(C1.c, C2.c);
    if (d > C1.r + C2.r + eps) {
        return 4;
    } else if (d > C1.r + C2.r -eps) {
        return 3;
    } else if (d > fabs(C1.r - C2.r) + eps) {
        return 2;
    } else if (d > fabs(C1.r - C2.r) - eps) {
        return 1;
    } else {
        return 0;
    }
}

class Vector {
public:
    double x, y;
    Vector(double _x = 0., double _y = 0.) : x(_x), y(_y) {}
    Vector(const Point& P) : x(P.x), y(P.y) {}
    Vector(const Point& St, const Point& End) : x(End.x - St.x), y(End.y - St.y) {}
    inline double InnerProd(const Vector& V)
    {
        return x * V.x + y * V.y;
    }
    inline double OuterProd(const Vector& V)
    {
        return x * V.y - y * V.x;
    }
    inline double Length()
    {
        return sqrt((*this).InnerProd(*this));
    }
};

Vector operator+(const Vector& V1, const Vector& V2)
{
    return Vector(V1.x + V2.x, V1.y + V2.y);
}

Vector operator-(const Vector& V1, const Vector& V2)
{
    return Vector(V1.x - V2.x, V1.y - V2.y);
}

Vector operator*(double d, const Vector& V)
{
    return Vector(d * V.x, d * V.y);
}

Vector operator/(const Vector&V, double d)
{
    return Vector(V.x / d, V.y / d);
}

bool operator<(const Vector& V1, const Vector& V2)
{
    return V1.x < V2.x || (V1.x == V2.x && V1.y < V2.y);
}

ostream& operator<<(ostream& out, const Vector V)
{
    out << V.x << " " << V.y;
    return out;
}

void PrintCross(const Circle& C, const Point& St, const Point& End)
{
    Vector LineVec(St, End);
    Vector LineUnitVec = LineVec / LineVec.Length();
    Vector RefVec(St, C.c);
    double ParaDist = LineUnitVec.InnerProd(RefVec);
    double PerpDist = fabs(LineUnitVec.OuterProd(RefVec));
    double ParaDistDiff = sqrt(C.r * C.r - PerpDist * PerpDist);
    Vector Res1 = St + (ParaDist - ParaDistDiff) * LineUnitVec;
    Vector Res2 = St + (ParaDist + ParaDistDiff) * LineUnitVec;
    if (Res2 < Res1) {
        swap(Res1, Res2);
    }
    cout << Res1 << " " << Res2 << endl;
}

void PrintCrossCircles(const Circle& C1, const Circle& C2)
{
    double d = Dist(C1.c, C2.c);
    double Cos = (d * d + C1.r * C1.r - C2.r * C2.r) / (2 * d * C1.r);
    double Sin = sqrt(max(0., 1 - Cos * Cos));

    Vector ParaVec(C1.c, C2.c);
    Vector ParaUnitVec = ParaVec / ParaVec.Length();
    Vector PerpUnitVec(ParaUnitVec.y, -ParaUnitVec.x);
    
    Vector Res1 = C1.c + C1.r * Cos * ParaUnitVec + C1.r * Sin * PerpUnitVec;
    Vector Res2 = C1.c + C1.r * Cos * ParaUnitVec - C1.r * Sin * PerpUnitVec;

    if(Res2 < Res1) {
        swap(Res1, Res2);
    }
    cout << Res1 << " " << Res2 << endl;
}

Vector TiltVec(const Vector& V, double Theta)
{
    Vector Ret;
    Ret.x = V.x * cos(Theta) - V.y * sin(Theta);
    Ret.y = V.x * sin(Theta) + V.y * cos(Theta);
    return Ret;
}

void PrintTangentPoints(const Point& P, const Circle& C)
{
    double d = Dist(P, C.c);
    double l = sqrt(d * d - C.r * C.r);
    double Theta = asin(C.r / d);

    Vector RefVec(P, C.c);
    Vector RefUnitVec = RefVec / RefVec.Length();
    Vector Res1 = P + l * TiltVec(RefUnitVec, Theta);
    Vector Res2 = P + l * TiltVec(RefUnitVec, -Theta);

    if (Res2 < Res1) {
        swap(Res1, Res2);
    }
    cout << Res1 << endl << Res2 << endl;
}

void PrintCommonTangents(const Circle& C1, const Circle& C2)
{
    double d = Dist(C1.c, C2.c);
    Vector RefVec(C1.c, C2.c);
    Vector RefUnitVec = RefVec / RefVec.Length();
    vector<Vector> vRes;

    if (d > C1.r + C2.r + eps) {
        double Theta = acos((C1.r + C2.r) / d);
        vRes.push_back(C1.c + C1.r * TiltVec(RefUnitVec, Theta));
        vRes.push_back(C1.c + C1.r * TiltVec(RefUnitVec, -Theta));
    } else if (d > C1.r + C2.r -eps) {
        vRes.push_back(C1.c + C1.r * RefUnitVec);
    }

    if (d > fabs(C1.r - C2.r) + eps) {
        double Theta = acos((C1.r - C2.r) / d);
        vRes.push_back(C1.c + C1.r * TiltVec(RefUnitVec, Theta));
        vRes.push_back(C1.c + C1.r * TiltVec(RefUnitVec, -Theta));
    } else if (d > fabs(C1.r - C2.r) - eps) {
        if (C1.r > C2.r) {
            vRes.push_back(C1.c + C1.r * RefUnitVec);
        } else {
            vRes.push_back(C1.c - C1.r * RefUnitVec);
        }
    }

    sort(vRes.begin(), vRes.end());
    for (int i = 0; i < vRes.size(); ++i) {
        cout << vRes[i] <<endl;
    }
}

int main()
{
    Circle C1, C2;
    cin >> C1 >> C2;

    cout << fixed << setprecision(10);
    PrintCommonTangents(C1, C2);
    
    return 0;
}



Measured memory_bytes: 3704