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

using T = double;
const T EPS = 1e-10;
T torad(int deg) {return (T)(deg) * M_PI / 180;}
T todeg(T ang) {return ang * 180 / M_PI;}

/* Point */
using P = complex<T>;
#define x real()
#define y imag()
template <typename T> inline bool eq(T p, T q) { return abs(p - q) < EPS; }
inline int sgn(T x) { return (T(0) < x) - (x < T(0)); }
inline T dot(P v, P w) { return (conj(v) * w).x; }
inline T cross(P v, P w) { return (conj(v) * w).y; }
inline bool isOrth(P v, P w) { return dot(v, w) == 0; }
inline bool isPara(P v, P w) { return cross(v, w) == 0; }
inline P translate(P p, P v) { return p + v; }
inline P scale(P p, P c, T k) { return c + (p - c) * k; }
inline P rot(P p, T a) { return p * polar(1.0, a); }
inline P rot90(P p) { return {-p.y, p.x}; }
inline T orient(P a, P b, P c) { return cross(b - a, c - a); }
istream& operator>>(istream& is, P& p) { T xx, yy; is >> xx >> yy; p = P(xx, yy); return is; }
bool sort_x(const P a, const P b) { return a.x != b.x ? a.x < b.x : a.y < b.y; }

P linearTransform(P p, P q, P fp, P fq, P r) {
    return fp + (r - p) * (fq - fp) / (q - p);
}

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

T angle(P v, P w) {
    T cosTheta = dot(v, w) / abs(v) / abs(w);
    return acos(max(-1.0, min(1.0, cosTheta)));
}
T orientedAngle(P a, P b, P c) {
    if (orient(a, b, c) >= 0) return angle(b - a, c - a);
    return 2 * M_PI - angle(b - a, c - a);
}
bool inAngle(P a, P b, P c, P p) {
    assert(abs(orient(a, b, c)) != 0);
    if (orient(a, b, c) < 0) swap(b, c);
    return orient(a, b, p) >= 0 && orient(a, c, p) <= 0;
}

// polar sort
bool half(P p) {
    assert(p.x != 0 || p.y != 0);
    return p.y > 0 || (p.y == 0 && p.x < 0);
}
void polarSort(vector<P>& v, P o = P(0.0, 0.0)) {
    sort(v.begin(), v.end(), [&](P v, P w) {
        return make_tuple(half(v - o), 0, norm(v - o)) <
            make_tuple(half(w - o), cross(v - o, w - o), norm(w - o));
    });
}

/* Line */
struct L : array<P, 2> {
    P v; T c;
    L(P a = P(0.0, 0.0), P b = P(0.0, 0.0)) : array<P, 2>({a, b}), v(b - a), c(cross(v, a)) {}
    T side(P p) { return cross(v, p) - c; }
    P proj(P p) { return p - rot90(v) * side(p) / norm(v); }
    P refl(P p) { return p - rot90(v) * T(2) * side(p) / norm(v); }
    friend ostream& operator << (ostream& os, const L& l) { return os << '{' << l[0] << ", " << l[1] << '}'; }
};

/* Circle */
struct C : P {
    T r;
    C(P p = P(0.0, 0.0), T r = 0.0) : P(p), r(r) {}
    friend ostream& operator << (ostream& os, const C& c) { return os << '(' << c.x << ", " << c.y << ", " << c.r << ')'; }
};

P circumCenter(P a, P b, P c) {
    b -= a, c -= a;
    assert(cross(b, c) != 0);
    return a + rot90(b * norm(c) - c * norm(b)) / cross(b, c) / T(2);
}

vector<P> tangentPoints(C c, P p) {
    if (eq(abs(p - c), c.r)) return vector<P>{p};
    vector<P> res;
    T t = acos(c.r / abs(p - c));
    P q = (p - c) / abs(p - c) * c.r;
    res.push_back(c + q * polar(1.0, t));
    res.push_back(c + q * polar(1.0, -t));
    sort(res.begin(), res.end(), sort_x);
    return res;
}

// intersect
bool isInterPL(P p, L l) { return (ccw(l[0], l[1], p) != 1); }
bool isInterPS(P p, L s) { return (ccw(s[0], s[1], p) == 0); }
bool isInterLL(L l, L m) { return (!isPara(l.v, m.v)); }
bool isInterLS(L l, L s) {
    if (eq(s[0], s[1])) return isInterPL(s[0], l);
    return (ccw(l[0], l[1], s[0]) * ccw(l[0], l[1], s[1]) <= 0);
}
bool isInterSS(L s, L t) {
    if (eq(s[0], s[1])) return isInterPL(s[0], t);
    if (eq(t[0], t[1])) return isInterPL(t[0], s);
    return (ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
            ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0);
}
int isInterCC(C c1, C c2) {
    if (c1.r < c2.r) swap(c1, c2), swap(c1.r, c2.r);
    T d = abs(c2 - c1);
    if (c1 == c2 && c1.r == c2.r) return -1;  // identical
    if (d > c1.r + c2.r) return 0;  // no intersection
    if (d = c1.r + c2.r) return 1;  // circumscribed
    if (d = c1.r - c2.r) return 3;  // inscribed
    if (d < c1.r - c2.r) return 4;  // inclusion
    return 2;  // intersection
}
 
// distance
T distancePL(P p, L l) { return (abs(p - l.proj(p))); }
T distancePS(P p, L s) {
    P h = s.proj(p);
    if (isInterPS(h, s)) return abs(p - h);
    return min(abs(p - s[0]), abs(p - s[1]));
}
T distanceLL(L l, L m) {
    if (isInterLL(l, m)) return T(0);
    return distancePL(m[0], l);
}
T distanceLS(L l, L s) {
    if (isInterLS(l, s)) return 0;
    return min(distancePL(s[0], l), distancePL(s[1], l));
}
T distanceSS(L s, L t) {
    if (isInterSS(s, t)) return 0;
    return min({distancePS(s[0], t), distancePS(s[1], t), distancePS(t[0], s), distancePS(t[1], s)});
}

// crosspoint
vector<P> crosspointLL(L l, L m) {
    if (!isInterLL(l, m)) return vector<P>();
    vector<P> res;
    T d0 = distancePL(m[0], l), d1 = distancePL(m[1], l);
    res.push_back((m[0] * d1 - m[1] * d0) / (d1 - d0));
    return res;
}
vector<P> crosspointLS(L l, L s) {
    if (!isInterLS(l, s)) return vector<P>();
    vector<P> res;
    T d0 = distancePL(s[0], l), d1 = distancePL(s[1], l);
    res.push_back((s[0] * d1 - s[1] * d0) / (d1 - d0));
    return res;
}
vector<P> crosspointLC(L l, C c) {
    if (abs(c - l.proj(c)) > c.r) return vector<P>();
    vector<P> res;
    T d = distancePL(c, l), h2 = c.r * c.r - d * d;
    assert(h2 >= 0);
    P p = l.proj(c), h = l.v * sqrt(h2) / abs(l.v);
    res.push_back(p - h);
    if (abs(h) > 0) res.push_back(p + h);
    return res;
}
vector<P> crosspointSS(L s, L t) {
    if (!isInterSS(s, t)) return vector<P>();
    vector<P> res;
    if (s.v != t.v) {
        T d0 = distancePL(s[0], t), d1 = distancePL(s[1], t);
        res.push_back((s[0] * d1 - s[1] * d0) / (d1 - d0));
    } else {
        if (ccw(s[0], s[1], t[0]) == 0) res.push_back(t[0]);
        if (ccw(s[0], s[1], t[1]) == 0) res.push_back(t[1]);
        if (ccw(t[0], t[1], s[0]) == 0) res.push_back(s[0]);
        if (ccw(t[0], t[1], s[1]) == 0) res.push_back(s[1]);
    }
    return res;
}
vector<P> crosspointSC(L s, C c) {
    if (abs(c - s.proj(c)) > c.r) return vector<P>();
    vector<P> res;
    T d = distancePL(c, s), h2 = c.r * c.r - d * d;
    assert(h2 >= 0);
    P p = s.proj(c), h = s.v * sqrt(h2) / abs(s.v);
    if (ccw(s[0], s[1], p - h) == 0) res.push_back(p - h);
    if (abs(h) > 0 && ccw(s[0], s[1], p + h) == 0) res.push_back(p + h);
    return res;
}
vector<P> crosspointCC(C c1, C c2) {
    P d = c2 - c1; T d2 = norm(d);
    if (d2 == 0) { assert(c1.r != c2.r); return vector<P>(); }
    vector<P> res;
    T pd = (d2 + c1.r * c1.r - c2.r * c2.r) / 2;
    T h2 = c1.r * c1.r - pd * pd / d2;
    if (h2 >= 0) {
        P p = c1 + d * pd / d2, h = rot90(d) * sqrt(h2 / d2);
        res.push_back(p - h);
        if (abs(h) > 0) res.push_back(p + h);
    }
    return res;
}

/* Polygon */
bool isConvex(vector<P> p) {
    bool pos = false, neg = false;
    for (int i = 0, n = p.size(); i < n; ++i) {
        int o = orient(p[i], p[(i + 1) % n], p[(i + 2) % n]);
        if (o > 0) pos = true;
        if (o < 0) neg = true;
    }
    return !(pos && neg);
}
T areaTriangle(P a, P b, P c) {
    return abs(cross(b - a, c - a)) / T(2);
}
bool above(P a, P p) { return p.y >= a.y; }
bool crossesRay(P a, P p, P q) {
    return (above(a, q) - above(a, p)) * orient(a, p, q) > 0;
}
// if strict, returns false when A is on the boundary
bool inPolygon(vector<P> p, P a, bool strict = true) {
    int numCrossing = 0;
    for (int i = 0, n = p.size(); i < n; ++i) {
        if (ccw(p[i], p[(i + 1) % n], a) == 0)
            return !strict;
        numCrossing += crossesRay(a, p[i], p[(i + 1) % n]);
    }
    return numCrossing & 1;
}
vector<P> convexHull(vector<P> p) {
    int n = p.size(), k = 0;
    sort(p.begin(), p.end(), sort_x);
    vector<P> res(2 * n);
    for (int i = 0; i < n; res[k++] = p[i++])
        while (k >= 2 && ccw(res[k - 2], res[k - 1], p[i]) <= 0) --k;
    for (int i = n - 2, t = k + 1; i >= 0; res[k++] = p[i--])
        while (k >= t && ccw(res[k - 2], res[k - 1], p[i]) <= 0) --k;
    res.resize(k - 1);
    return res;
}
vector<P> convexHullCollinearOK(vector<P> p) {
    int n = p.size(), k = 0;
    sort(p.begin(), p.end(), sort_x);
    vector<P> res(2 * n);
    for (int i = 0; i < n; res[k++] = p[i++])
        while (k >= 2 && ccw(res[k - 2], res[k - 1], p[i]) == -1) --k;
    for (int i = n - 2, t = k + 1; i >= 0; res[k++] = p[i--])
        while (k >= t && ccw(res[k - 2], res[k - 1], p[i]) == -1) --k;
    res.resize(k - 1);
    return res;
}

int main() {
    cout << fixed << setprecision(10);
    P p;
    C c;
    cin >> p >> c >> c.r;
    auto ps = tangentPoints(c, p);
    cout << ps[0].x << " " << ps[0].y << endl;
    cout << ps[1].x << " " << ps[1].y << endl;
}


Measured memory_bytes: 3572