Find the tangent lines between a point $p$ and a circle $c$.

Constraints

* $-1,000 \leq px, py, cx, cy \leq 1,000$
* $1 \leq r \leq 1,000$
* Distance between $p$ and the center of $c$ is greater than the radius of $c$.

Input

The input is given in the following format.

$px \; py$
$cx \; cy \; r$

$px$ and $py$ represents the coordinate of the point $p$. $cx$, $cy$ and $r$ represents the center coordinate and radius of the circle $c$ respectively. All input values are given in integers.

Output

Print coordinates of the tangent points on the circle $c$ 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

0 0
2 2 2


Output

0.0000000000 2.0000000000
2.0000000000 0.0000000000


Input

-3 0
2 2 2


Output

0.6206896552 3.4482758621
2.0000000000 0.0000000000
/* Header {{{ */
#include <bits/stdc++.h>
using namespace std;

typedef long long readtype;
typedef long long var;
typedef long double let;

readtype read() {
  readtype a = 0, c = getchar(), s = 0;
  while (!isdigit(c)) s |= c == '-', c = getchar();
  while (isdigit(c)) a = a * 10 + c - 48, c = getchar();
  return s ? -a : a;
}

#ifdef LOCAL_LOGGER
#define logger(...) fprintf(stderr, __VA_ARGS__)
#define abortif(v, ...) if (v) {logger("Error in Line %d, Function '%s()'.\nInfo: ", __LINE__, __FUNCTION__); logger(__VA_ARGS__); exit(0);}
#else
#define logger(...);
#define abortif(v, ...);
#endif
/* }}} */

const let eps = 1e-8;

int sign(let x) { return (x < -eps) ? -1 : (x > eps ? 1 : 0); }

struct Point {
  let x, y;
  let dist() {
    return sqrt(x * x + y * y);
  }
  Point Rotate(let sink, let cosk) {
    return (Point) {
      x * cosk - y * sink, x * sink + y * cosk
    };
  }
  Point Rotate(Point v) {
    let z = v.dist();
    return Rotate(v.y / z, v.x / z);
  }
  friend Point operator + (Point a, Point b) {
    return (Point) {a.x + b.x, a.y + b.y};
  }
  friend Point operator - (Point a, Point b) {
    return (Point) {a.x - b.x, a.y - b.y};
  }
  Point operator ~ () {
    return (Point) {x, -y};
  }
  friend bool operator < (Point a, Point b) {
    if (sign(a.x - b.x) == 0) return sign(a.y - b.y) < 0;
    return sign(a.x - b.x) < 0;
  }
  void EchoWith(char c) {
    printf("%.8Lf %.8Lf", x, y);
    putchar(c);
  }
};

typedef Point Vec;

struct Segment {
  Point s, e;
  Vec v;

  Segment operator + (Vec x) {
    return (Segment) {
      s + x, e + x, v
    };
  }

  Segment Rotate(let sink, let cosk) {
    return (Segment) {
      s.Rotate(sink, cosk), e.Rotate(sink, cosk), v.Rotate(sink, cosk)
    };
  }

  Segment Rotate(Vec v) {
    let z = v.dist();
    return Rotate(v.y / z, v.x / z);
  }

};

struct Circle {
  Point o;
  let r;
};

Segment MoveCutX(Point a, Point b, Point an, Point bn) {
  // a.EchoWith('|'), b.EchoWith('\n');
  // an.EchoWith('|'), bn.EchoWith('\n');
  // puts("");

  Point ov = b - a, tv = bn - an, dx = a - an;
  Segment s = (Segment) {
    (Point) {an.x, 0}, (Point) {bn.x, 0}
  };
  return s.Rotate(~tv).Rotate(ov) + dx;
}

pair<Point, Point> Tangent(Circle c, Point p) {
  let d = (p - c.o).dist();
  Point up = (Point) {sqrt(d * d - c.r * c.r), c.r},
        dp = ~up;
  Segment us = MoveCutX(p, c.o, (Point) {0, 0}, up),
          ds = MoveCutX(p, c.o, (Point) {0, 0}, dp);
  up = us.e, dp = ds.e;
  if (dp < up) swap(up, dp);
  return make_pair(up, dp);
}


Point ReadPoint() {
  Point p;
  scanf("%Lf%Lf", &p.x, &p.y);
  return p;
}

Circle ReadCirle() {
  let c;
  Point p = ReadPoint();
  scanf("%Lf", &c);
  return (Circle) {p, c};
}

int main() {
// #ifndef ONLINE_JUDGE
//   freopen("CGL_7_F.in", "r", stdin);
//   freopen("CGL_7_F.out", "w", stdout);
// #endif
// #ifdef LOCAL_LOGGER
//   freopen("CGL_7_F.log", "w", stderr);
// #endif
  Point p = ReadPoint();
  Circle c1 = ReadCirle();
  Tangent(c1, p);
  pair<Point, Point> res = Tangent(c1, p);
  res.first.EchoWith('\n');
  res.second.EchoWith('\n');
  return 0;
}

/* ==== Makefile ==== {{{
CompileAndRun:
	make Compile
	make Run

Compile:
	g++ -o CGL_7_E CGL_7_E.cpp -g -Wall -DLOCAL_LOGGER

CompileUF:
	g++ -o CGL_7_E CGL_7_E.cpp -g -Wall -DLOCAL_LOGGER -fsanitize=undefined

Run:
	./CGL_7_E < CGL_7_E.in > CGL_7_E.out
==================
}}} */

