Problem: 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

Solution (in CPP):

Solution:
#include<cstdio>
#include<vector>
#include<algorithm>
#include<utility>
#include<numeric>
#include<iostream>
#include<array>
#include<string>
#include<sstream>
#include<stack>
#include<queue>
#include<list>
#include<functional>
#include<set>
#include<complex>
#include<complex>
#define _USE_MATH_DEFINES

#include<math.h>
#include<map>

#define INF 200000000

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;

enum
{
	BOTTOM,
	LEFT,
	RIGHT,
	TOP
};

struct P
{
	double x, y;
	P(double x,double y) :x(x), y(y) {}
	P() :P(0, 0) {}
	P operator+(const P& v)const
	{
		return P(x + v.x, y + v.y);
	}
	P operator-(const P& v)const
	{
		return P(x - v.x, y - v.y);
	}
	P operator*(const double v)const
	{
		return P(x*v, y*v);
	}
	bool operator==(const P& v)const
	{
		return abs(x - v.x) <= 0.0000000000001&&abs(y - v.y) <= 0.00000000000001;
	}
	bool operator!=(const P& v)const
	{
		return abs(x - v.x) > 0.0000000000001 || abs(y - v.y) > 0.00000000000001;
	}

	double dot(const P& v)const
	{
		return x*v.x + y*v.y;
	}
	double cross(const P& v)const
	{
		return x*v.y - y*v.x;
	}
	double length()const
	{
		return sqrt(x*x + y*y);
	}
	double length2()const
	{
		return (x*x + y*y);
	}

	P unit()const
	{
		return P(x / length(), y / length());
	}
	
	bool operator<(const P& v)const
	{
		return x<v.x || (x == v.x) && y < v.y;
	}
	bool operator>(const P& v)const
	{
		return x>v.x || (x == v.x) && y > v.y;
	}
};

pair<P,P> cli(double a, double b, double c, double x1, double y1, double r)
{
	double l = a*a + b*b, k = a*x1 + b*y1 + c, d = l*r*r - k*k;
	if (d > 0)
	{
		double ds = sqrt(d), apl = a / l, bpl = b / l, xc = x1 - apl*k, yc = y1 - bpl*k, xd = bpl*ds, yd = apl*ds;
		return make_pair(P(xc - xd, yc + yd), P(xc + xd, yc - yd));
	}
	else
	{
		return make_pair(P(x1 - a*k / l, y1 - b*k / l), P(x1 - a*k / l, y1 - b*k / l));
	}
}

pair<P, P> cci(P p1, P p2, double r1, double r2)
{
	double a = p1.x - p2.x, b = p1.y - p2.y;
	return cli(a, b, 0.5*((r1 - r2)*(r1 + r2) - a*(p1.x + p2.x) - b*(p1.y + p2.y)), p1.x, p1.y, r1);
}

int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	double px, py, cx, cy, r;
	cin >> px >> py >> cx >> cy >> r;
	
	px -= cx;
	py -= cy;
	pair<P, P> tanp = make_pair(P(r*(px*r + py*sqrt(px*px + py*py - r*r)) / (px*px + py*py) + cx, r*(py*r - px*sqrt(px*px + py*py - r*r)) / (px*px + py*py) + cy), P(r*(px*r - py*sqrt(px*px + py*py - r*r)) / (px*px + py*py) + cx, r*(py*r + px*sqrt(px*px + py*py - r*r)) / (px*px + py*py) + cy));
	if (tanp.first > tanp.second)
	{
		swap(tanp.first, tanp.second);
	}

	printf("%.10lf %.10lf\n%.10lf %.10lf\n", tanp.first.x, tanp.first.y, tanp.second.x, tanp.second.y);

	return 0;
}