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 <bits/stdc++.h>
using namespace std;

typedef long long ll;

#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount

typedef long double D;
typedef complex<D> P;

#define X real()
#define Y imag()

const D eps=1e-8;
const D inf=1e12;
const D PI=acos(-1);

namespace std{
  bool operator<(const P& a,const P& b){
    return a.X==b.X?a.Y<b.Y:a.X<b.X;
  }
}
bool cmp_x(const P& a,const P& b){ return abs(a.X-b.X)<eps?a.Y<b.Y:a.X<b.X; }
bool cmp_y(const P& a,const P& b){ return abs(a.Y-b.Y)<eps?a.X<b.X:a.Y<b.Y; }
bool cmp_a(const P& a,const P& b){ return arg(a)==arg(b)?norm(a)<norm(b):arg(a)<arg(b); }
D cross(P a,P b){ return (conj(a)*b).Y; }
D dot(P a,P b){ return (conj(a)*b).X; }
D toRag(D deg){ return deg*PI/180.0; }
P rot(P base,P a,D theta){ return base+polar(abs(a-base),arg(a-base)+theta); }

struct L : public vector<P> { // line and segment
  L(P a,P b){
    push_back(a);
    push_back(b);
  }
};

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

enum RELATION{SAME=1,CONTAINED=2,OVER=4,NO_CROSS=8,ONE_CROSS=16,ONE_CONTAINED_CROSS=32,ONE_OVER_CROSS=64,TWO_CROSS=128};
int cRel(C c1, C c2) {
  D d=abs(c1.p-c2.p);
  D dr1=c1.r-c2.r,dr2=c2.r-c1.r;
  D ar=c1.r+c2.r;
  if(d<eps&&c1.r==c2.r)return SAME;
  if(d<dr1)return OVER;
  if(d<dr2)return CONTAINED;
  if(d==dr1)return ONE_OVER_CROSS;
  if(d==dr2)return ONE_CONTAINED_CROSS;
  if(d==ar)return ONE_CROSS;
  if(d>ar)return NO_CROSS;
  return TWO_CROSS;
}

// 2????????±?????\???
L tanC(C c,D t){
  P p=c.p+polar(c.r,t);
  P d=polar(c.r,t)*P(0,1);
  return L(p-d,p+d);
}
vector<L> tanCC(C c1,C c2){
  vector<L> res;
  D d=arg(c2.p-c1.p),d2=arg(c1.p-c2.p);
  D i=acos((c1.r+c2.r)/abs(c2.p-c1.p));
  D o=acos((c1.r-c2.r)/abs(c2.p-c1.p));
  int r=cRel(c1,c2);
  if(r==NO_CROSS){
    res.push_back(tanC(c1,d+i));
    res.push_back(tanC(c1,d-i));
  }
  if(!(r&(SAME|CONTAINED|OVER|ONE_CONTAINED_CROSS|ONE_OVER_CROSS))){
    res.push_back(tanC(c1,d+o));
    res.push_back(tanC(c1,d-o));
  }
  if(r&(ONE_CROSS|ONE_CONTAINED_CROSS|ONE_OVER_CROSS)){
    if(r&ONE_CONTAINED_CROSS) res.push_back(tanC(c2,d2));
    else res.push_back(tanC(c1,d));
  }
  return res;
}

P projection(L l,P p){
  P b=l[1]-l[0],c=p-l[0];
  return l[0]+b*(c/b).X;
}


int main(){
	cin.sync_with_stdio(false);
  D x,y;
  D cx,cy,cr;
  cin>>x>>y>>cx>>cy>>cr;

  C cc=C(P(cx,cy),cr);
  vector<L> ls=tanCC(cc,C(P(x,y),0));
  vector<P> res;
  rep(i,ls.size()){
    P ans=projection(ls[i],cc.p);
    res.push_back(ans);
  }
  sort(all(res),cmp_x);
  uni(res);
  rep(i,res.size()){
    printf("%.10Lf %.10Lf\n", res[i].X,res[i].Y);
  }
  return 0;
}