Problem:
Problem K
Runner and Sniper
You are escaping from an enemy for some reason. The enemy is a sniper equipped with a high-tech laser gun, and you will be immediately defeated if you get shot. You are a very good runner, but just wondering how fast you have to run in order not to be shot by the sniper. The situation is as follows:
You and the sniper are on the $xy$-plane whose $x$-axis and $y$-axis are directed to the right and the top, respectively. You can assume that the plane is infinitely large, and that there is no obstacle that blocks the laser or your movement.
The sniper and the laser gun are at $(0, 0)$ and cannot move from the initial location. The sniper can continuously rotate the laser gun by at most $\omega$ degrees per unit time, either clockwise or counterclockwise, and can change the direction of rotation at any time. The laser gun is initially directed $\theta$ degrees counterclockwise from the positive direction of the $x$-axis.
You are initially at ($x$, $y$) on the plane and can move in any direction at speed not more than $v$ (you can arbitrarily determine the value of $v$ since you are a very good runner). You will be shot by the sniper exactly when the laser gun is directed toward your position, that is, you can ignore the time that the laser reaches you from the laser gun. Assume that your body is a point and the laser is a half-line whose end point is (0, 0).
Find the maximum speed $v$ at which you are shot by the sniper in finite time when you and the sniper behave optimally.
Input
The input consists of a single test case. The input contains four integers in a line, $x$, $y$, $\theta$ and $\omega$. The two integers $x$ and $y$ $(0 \leq |x|, |y| \leq 1,000$, ($x$, $y$) $\ne$ (0, 0)) represent your initial position on the $xy$-plane. The integer $\theta$ $(0 \leq \theta < 360)$ represents the initial direction of the laser gun: it is the counterclockwise angle in degrees from the positive direction of the $x$-axis. The integer $\omega$ $(1 \leq \omega \leq 100)$ is the angle which the laser gun can rotate in unit time. You can assume that you are not shot by the sniper at the initial position.
Output
Display a line containing the maximum speed $v$ at which you are shot by the sniper in finite time. The
absolute error or the relative error should be less than $10^{-6}$.
Sample Input 1
100 100 0 1
Output for the Sample Input 1
1.16699564

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;
typedef complex<double> P;

double modf(double x){
  while(x>2*PI){
    x-=2*PI;
  }
  while(x<0){
    x+=2*PI;
  }
  return x;
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = modf(arg(p)) - distA*b*rate;
  
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  double tx=x,ty=y;
  double left=0,right=PI,midL,midR;
  
  if(x<0){
    left=PI*0.5;
    right=PI*1.5;
  }
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  bool res=  ( (check(v,midL) >= 0 )|| (check(v,midR) >=0) );
  
  x=tx;
  y=ty;
  return res;
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  //  assert( x>=0 || y==0);

  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 1
time_ms: 410
memory_kb: 3696
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;
typedef complex<double> P;

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  double tx=x,ty=y;

  if(x<0){
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;
    double dd=abs(P(x,y))-k*v;
    x=0,y=dd;
  }

  
  double left=0,right=PI,midL,midR;


  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  bool res=  ( (check(v,midL) >= 0 )|| (check(v,midR) >=0) );
  
  x=tx;
  y=ty;
  return res;
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  //  assert( x>=0 || y==0);
  double fg=1e9;
  if( x < 0 ){
    fg = abs(P(x,y)) / ( arg(P(x,y)) / b );
  }
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return min(fg,left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 290
memory_kb: 3744
final_rank: 15

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;
typedef complex<double> P;

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  double tx=x,ty=y;
  /*
  if(x<0){
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;
    double dd=abs(P(x,y))-k*v;
    x=0,y=dd;
  }
  */
  
  double left=0,right=PI,midL,midR;

  if( x < 0 ){
    left=arg(P(x,y));
    right=arg(P(x,y));
  }
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  bool res=  ( (check(v,midL) >= 0 )|| (check(v,midR) >=0) );
  
  x=tx;
  y=ty;
  return res;
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  //  assert( x>=0 || y==0);
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 280
memory_kb: 3664
final_rank: 13

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;
typedef complex<double> P;

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  double tx=x,ty=y;
  /*
  if(x<0){
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;
    double dd=abs(P(x,y))-k*v;
    x=0,y=dd;
  }
  */
  
  double left=0,right=PI,midL,midR;

  if( x < 0 ){
    left=arg(P(x,y));
    right=PI*1.5;
  }
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  bool res=  ( (check(v,midL) >= 0 )|| (check(v,midR) >=0) );
  
  x=tx;
  y=ty;
  return res;
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  //  assert( x>=0 || y==0);
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 350
memory_kb: 3576
final_rank: 16

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;
typedef complex<double> P;

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  double tx=x,ty=y;
  /*
  if(x<0){
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;
    double dd=abs(P(x,y))-k*v;
    x=0,y=dd;
  }
  */
  
  double left=0,right=PI,midL,midR;

  if( x < 0 ){
    left=PI;
    right=PI*1.9999999999;
  }
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  bool res=  ( (check(v,midL) >= 0 )|| (check(v,midR) >=0) );
  
  x=tx;
  y=ty;
  return res;
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  //  assert( x>=0 || y==0);
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 280
memory_kb: 3696
final_rank: 14

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;
typedef complex<double> P;

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  double tx=x,ty=y;
  /*
  if(x<0){
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;
    double dd=abs(P(x,y))-k*v;
    x=0,y=dd;
  }
  */
  
  double left=0,right=PI,midL,midR;

  if( x < 0 ){
    left=PI;
    right=PI*1.9999999999;
  }
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  bool res=  ( (check(v,midL) >= 0 )|| (check(v,midR) >=0) );
  
  x=tx;
  y=ty;
  return res;
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  assert( x>=0 || y==0);
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 240
memory_kb: 3608
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v,bool flag=false){



  
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  if(x<0){
    double tx=x;
    double ty=y;
    
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;
    double dd=abs(P(x,y))-k*v;
    x=0,y=dd;
    
    double left=0,right=PI*1.5,midL,midR;
    for(int i=0;i<100;i++){
      double dist=(right-left)/3.0;
      midL=left+dist;
      midR=right-dist;
    
      double fl=check(v,midL);
      double fr=check(v,midR);
    
      if( fl < fr ){
        left=midL;
      }else{
        right=midR;
      }
    }

    bool res=(check(v,midL) >= 0 )|| (check(v,midR) >=0);
    x=tx;
    y=ty;
    return res;
  }

  double left=0,right=PI*1.5,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());


  
  double left=0,right=1e9,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 260
memory_kb: 3664
final_rank: 12

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v,bool flag=false){



  
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  if(x<0){
    double tx=x;
    double ty=y;
    
    double k=(arg(P(x,y)) - PI*0.5)/b;
    if( k*v >= abs(P(x,y)) )return true;

    P np = P(x,y) / abs(P(x,y)) * (  abs(P(x,y))-k*v);
    x=np.real(); y=np.imag();
    
    double left=0,right=PI*1.5,midL,midR;
    for(int i=0;i<100;i++){
      double dist=(right-left)/3.0;
      midL=left+dist;
      midR=right-dist;
    
      double fl=check(v,midL);
      double fr=check(v,midR);
    
      if( fl < fr ){
        left=midL;
      }else{
        right=midR;
      }
    }

    bool res=(check(v,midL) >= 0 )|| (check(v,midR) >=0);
    x=tx;
    y=ty;
    return res;
  }

  double left=0,right=PI*1.5,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());


  
  double left=0,right=1e9,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 420
memory_kb: 3712
final_rank: 18

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v,bool flag=false){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  double left=0,right=PI,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }
  
  if(flag){
    cout<<left<<' '<<right<<endl;
    cout<<left/PI<<' '<<right/PI<<endl; 
  }
  
  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());


  
  double left=0,right=1e9,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 410
memory_kb: 3680
final_rank: 17

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v,bool flag=false){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  double left=0,right=PI,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }
  
  if(flag){
    cout<<left<<' '<<right<<endl;
    cout<<left/PI<<' '<<right/PI<<endl; 
  }
  
  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();

  assert(y>=0);
  
  y=abs(p.imag());


  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 470
memory_kb: 3576
final_rank: 19

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v,bool flag=false){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  double left=0,right=PI,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }
  
  if(flag){
    cout<<left<<' '<<right<<endl;
    cout<<left/PI<<' '<<right/PI<<endl; 
  }
  
  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  assert(x>=0);
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  //  func(left,true);
  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 240
memory_kb: 3532
final_rank: 9

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v,bool flag=false){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  double left=0,right=PI,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }
  
  if(flag){
    cout<<left<<' '<<right<<endl;
    cout<<left/PI<<' '<<right/PI<<endl; 
  }
  
  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  assert(x>=0);
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  //  func(left,true);
  return left;
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 240
memory_kb: 3608
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

double compute(double v,double m,double rate){
  double R=v/b;

  P target=polar(R,m);
  double distA=abs( target - P(x,y) ) / v;
  P base=target-P(x,y);
  P p = P(x,y) + ( base * rate );
  double f = arg(p) - distA*b*rate;
  return f;
}

double check(double v,double m){
  double left=0,right=1,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl = compute(v,m,midL);
    double fr = compute(v,m,midR);
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return compute(v,m,left);
}

bool func(double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;
  
  double left=0,right=PI,midL,midR;
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    double fl=check(v,midL);
    double fr=check(v,midR);
    
    if( fl < fr ){
      left=midL;
    }else{
      right=midR;
    }
  }

  return (check(v,midL) >= 0 )|| (check(v,midR) >=0);
}

double solve(){
  
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  check(1.0,0.5);
  
  double left=0,right=1e5,mid;
  
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if( func(mid) ) right=mid;
    else left=mid;
  }

  return left;

}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 470
memory_kb: 3664
final_rank: 20

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double x,y,a,b;

bool check(double m,double v){
  // R*b == v
  // R==v/b
  double R=v/b;
  
  if( abs( P(x,y) ) < R+eps )return true;

  P target=polar(R,m);
  
  double distA=abs( target - P(x,y) ) / v;

  if( distA*b > m+eps )return false;

  double left=0,right=1,midL,midR;
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    P base=target-P(x,y);
    P pl = P(x,y) + ( base * midL );
    P pr = P(x,y) + ( base * midR );
    
    double fl = arg(pl) - distA*b*midL;
    if(fl<-eps)return false;
    
    double fr = arg(pr) - distA*b*midR;
    if(fr<-eps)return false;
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return true;

}

double func(double m){
  double left=0,right=1e9,mid;
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if(check(m,mid))right=mid;
    else left=mid;
  }
  return left;
}

double solve(){
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());
  
  double left=0,right=PI,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    if( func(midL) < func(midR) ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return func(left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 60
memory_kb: 3740
final_rank: 3

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double dot(P a,P b){ return real( b*conj(a) ); }
double cross(P a,P b){ return imag( b*conj(a) ); }

double calcdist(P a,P b,P p){
  if( dot(b-a,p-a) < 0 )return abs(p-a);
  if( dot(a-b,p-b) < 0 )return abs(p-b);
  return abs( cross(b-a,p-a) ) / abs(b-a);
}

double x,y,a,b;

bool check(double m,double v){
  // R*b == v
  // R==v/b
  
  
  double R=v/b;
  if( abs( P(x,y) ) <= R )return true;

  P target=polar(R,m);
  //  if( abs(target) < 1e-10 ) return false;

  
  //  if( calcdist(target , P(x,y) , P(0,0) ) < R-eps )return false;
  
  double distA=abs( target - P(x,y) ) / v;

  if( distA*b > m )return false;

  double left=0,right=1,midL,midR;
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    P base=target-P(x,y);
    P pl = P(x,y) + ( base * midL );
    P pr = P(x,y) + ( base * midR );
    
    double fl = arg(pl) - distA*b*midL;
    if(fl<0)return false;
    
    double fr = arg(pr) - distA*b*midR;
    if(fr<0)return false;
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return true;

}

double func(double m){
  double left=0,right=10000,mid;
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if(check(m,mid))right=mid;
    else left=mid;
  }
  return left;
}

double solve(){
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  //  y=abs(p.imag());
  y=p.imag();
  
  if(y<=0){
    return func( arg(P(x,y)) );
  }
  
  //  cout<<x<<' '<<y<<endl;
  
  double left=0,right=PI,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    if( func(midL) < func(midR) ){
      right=midR;
    }else{
      left=midL;
    }
  }

  //  printf("%.10f\n",left/PI);
  return func(left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 70
memory_kb: 3612
final_rank: 5

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double dot(P a,P b){ return real( b*conj(a) ); }
double cross(P a,P b){ return imag( b*conj(a) ); }

double calcdist(P a,P b,P p){
  if( dot(b-a,p-a) < 0 )return abs(p-a);
  if( dot(a-b,p-b) < 0 )return abs(p-b);
  return abs( cross(b-a,p-a) ) / abs(b-a);
}

double x,y,a,b;

bool check(double m,double v){
  // R*b == v
  // R==v/b
  
  
  double R=v/b;
  if( abs( P(x,y) ) <= R )return true;

  P target=polar(R,m);
  //  if( abs(target) < 1e-10 ) return false;

  
  //  if( calcdist(target , P(x,y) , P(0,0) ) < R-eps )return false;
  
  double distA=abs( target - P(x,y) ) / v;

  if( distA*b > m )return false;

  double left=0,right=1,midL,midR;
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    P base=target-P(x,y);
    P pl = P(x,y) + ( base * midL );
    P pr = P(x,y) + ( base * midR );
    
    double fl = arg(pl) - distA*b*midL;
    if(fl<0)return false;
    
    double fr = arg(pr) - distA*b*midR;
    if(fr<0)return false;
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return true;

}

double func(double m){
  double left=0,right=10000,mid;
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if(check(m,mid))right=mid;
    else left=mid;
  }
  return left;
}

double solve(){
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  if(x<=0){
    return func( arg(P(x,y)) );
  }
  
  //  cout<<x<<' '<<y<<endl;
  
  double left=0,right=PI,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    if( func(midL) < func(midR) ){
      right=midR;
    }else{
      left=midL;
    }
  }

  //  printf("%.10f\n",left/PI);
  return func(left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 70
memory_kb: 3532
final_rank: 4

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double dot(P a,P b){ return real( b*conj(a) ); }
double cross(P a,P b){ return imag( b*conj(a) ); }

double calcdist(P a,P b,P p){
  if( dot(b-a,p-a) < 0 )return abs(p-a);
  if( dot(a-b,p-b) < 0 )return abs(p-b);
  return abs( cross(b-a,p-a) ) / abs(b-a);
}

double x,y,a,b;

bool check(double m,double v){
  // R*b == v
  // R==v/b
  
  
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  P target=polar(R,m);
  if( abs(target) < eps ) return false;

  
  //  if( calcdist(target , P(x,y) , P(0,0) ) < R-eps )return false;
  
  double distA=abs( target - P(x,y) ) / v;

  if( distA*b > m )return false;

  double left=0,right=1,midL,midR;
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    P base=target-P(x,y);
    P pl = P(x,y) + ( base * midL );
    P pr = P(x,y) + ( base * midR );
    
    double fl = arg(pl) - distA*b*midL;
    if(fl<0)return false;
    double fr = arg(pr) - distA*b*midR;
    if(fr<0)return false;
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return true;

}

double func(double m){
  double left=0,right=10000,mid;
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if(check(m,mid))right=mid;
    else left=mid;
  }
  return left;
}

double solve(){
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());

  if(x<=0){
    return func( arg(P(x,y)) );
  }
  
  //  cout<<x<<' '<<y<<endl;
  
  double left=0,right=PI,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    if( func(midL) < func(midR) ){
      right=midR;
    }else{
      left=midL;
    }
  }

  //  printf("%.10f\n",left/PI);
  return func(left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 70
memory_kb: 3632
final_rank: 7

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double dot(P a,P b){ return real( b*conj(a) ); }
double cross(P a,P b){ return imag( b*conj(a) ); }

double calcdist(P a,P b,P p){
  if( dot(b-a,p-a) < 0 )return abs(p-a);
  if( dot(a-b,p-b) < 0 )return abs(p-b);
  return abs( cross(b-a,p-a) ) / abs(b-a);
}

double x,y,a,b;

bool check(double m,double v){
  // R*b == v
  // R==v/b
  
  
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  P target=polar(R,m);
  if( abs(target) < eps ) return false;

  
  // if( calcdist(target , P(x,y) , P(0,0) ) < R-eps )return false;
  
  double distA=abs( target - P(x,y) ) / v;

  if( distA*b > m )return false;

  double left=0,right=1,midL,midR;
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    P base=target-P(x,y);
    P pl = P(x,y) + ( base * midL );
    P pr = P(x,y) + ( base * midR );
    
    double fl = arg(pl) - distA*b*midL;
    if(fl<0)return false;
    double fr = arg(pr) - distA*b*midR;
    if(fr<0)return false;
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return true;

}

double func(double m){
  double left=0,right=10000,mid;
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if(check(m,mid))right=mid;
    else left=mid;
  }
  return left;
}

double solve(){
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());
  //  cout<<x<<' '<<y<<endl;
  
  double left=0,right=PI,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    if( func(midL) < func(midR) ){
      right=midR;
    }else{
      left=midL;
    }
  }

  //  printf("%.10f\n",left/PI);
  return func(left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 70
memory_kb: 3628
final_rank: 6

code_snippet: #include<bits/stdc++.h>
using namespace std;
double PI=acos(-1);
double eps=1e-7;

typedef complex<double> P;

double Sqrt(double x){
  if(x<0)return 0;
  return sqrt(x);
}

double dot(P a,P b){ return real( b*conj(a) ); }
double cross(P a,P b){ return imag( b*conj(a) ); }

double calcdist(P a,P b,P p){
  if( dot(b-a,p-a) < 0 )return abs(p-a);
  if( dot(a-b,p-b) < 0 )return abs(p-b);
  return abs( cross(b-a,p-a) ) / abs(b-a);
}

double x,y,a,b;

bool check(double m,double v){
  // R*b == v
  // R==v/b
  
  
  double R=v/b;
  if( abs( P(x,y) ) < R )return true;

  P target=polar(R,m);
  if( abs(target) < eps ) return false;

  
  // if( calcdist(target , P(x,y) , P(0,0) ) < R-eps )return false;
  
  double distA=abs( target - P(x,y) ) / v;

  if( distA*b > m )return false;

  double left=0,right=1,midL,midR;
  for(int i=0;i<100;i++){
    double dist=( right-left ) /3.0;
    midL=left+dist;
    midR=right-dist;
    
    P base=target-P(x,y);
    P pl = P(x,y) + ( base * midL );
    P pr = P(x,y) + ( base * midR );
    
    double fl = arg(pl) - distA*b*midL;
    if(fl<0)return false;
    double fr = arg(pr) - distA*b*midR;
    if(fr<0)return false;
    
    if( fl < fr ){
      right=midR;
    }else{
      left=midL;
    }
  }

  return true;

}

double func(double m){
  double left=0,right=100,mid;
  for(int i=0;i<100;i++){
    mid=(left+right)*0.5;
    if(check(m,mid))right=mid;
    else left=mid;
  }
  return left;
}

double solve(){
  P p=P(x,y) / polar(1.0, a);
  x=p.real();
  y=abs(p.imag());
  //  cout<<x<<' '<<y<<endl;
  
  double left=0,right=PI,midL,midR;
  
  for(int i=0;i<100;i++){
    double dist=(right-left)/3.0;
    midL=left+dist;
    midR=right-dist;
    
    if( func(midL) < func(midR) ){
      right=midR;
    }else{
      left=midL;
    }
  }

  //  printf("%.10f\n",left/PI);
  return func(left);
}

int main(){
  cin>>x>>y>>a>>b;
  a=a/180.0*PI;
  b=b/180.0*PI;
  printf("%.10f\n", (double)solve());
  return 0;
}
accuracy: 0.02040816326530612
time_ms: 80
memory_kb: 3680
final_rank: 8

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;


/* ??????????????¬ */

#include <complex>

typedef long double ld;
typedef complex<ld> Point;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()


const ld pi = acos(-1.0);
const ld dtop = pi / 180.;
const ld ptod = 1. / dtop;

namespace std {
	bool operator<(const Point &lhs, const Point &rhs) {
		if (lhs.real() < rhs.real() - eps) return true;
		if (lhs.real() > rhs.real() + eps) return false;
		return lhs.imag() < rhs.imag();
	}
}

// ????????\???
Point input_point() {
	ld x, y;
	cin >> x >> y;
	return Point(x, y);
}

// ????????????????????????
bool eq(const ld a, const ld b) {
	return (abs(a - b) < eps);
}

// ??????
ld dot(const Point& a, const Point& b) {
	return real(conj(a) * b);
}

// ??????
ld cross(const Point& a, const Point& b) {
	return imag(conj(a) * b);
}

// ??´????????????
class Line {
public:
	Point a, b;
	Line() : a(Point(0, 0)), b(Point(0, 0)) {}
	Line(Point a, Point b) : a(a), b(b) {}
	Point operator[](const int _num)const {
		if (_num == 0)return a;
		else if (_num == 1)return b;
		else {
			assert(false);
			return Point();
		}
	}
};

// ????????????
class Circle {
public:
	Point p;
	ld r;
	Circle() : p(Point(0, 0)), r(0) {}
	Circle(Point p, ld r) : p(p), r(r) {}
};

// CCW
int ccw(const Point& a, const Point &b, const Point &c) {
	const Point nb(b - a);
	const Point nc(c - a);
	if (cross(nb, nc) > eps) return 1;   // a,b,c??????????¨???¨?????????????????¶
	if (cross(nb, nc) < -eps) return -1; // a,b,c???????¨???¨?????????????????¶
	if (dot(nb, nc) < 0) return 2;       // c,a,b???????????´???????????¶
	if (norm(nb) < norm(nc)) return -2;  // a,b,c???????????´???????????¶
	return 0;                          // a,c,b???????????´???????????¶
}


/* ???????????? */

// ??´?????¨??´??????????????????
bool isis_ll(const Line& l, const Line& m) {
	return !eq(cross(l.b - l.a, m.b - m.a), 0);
}

// ??´?????¨?????????????????????
bool isis_ls(const Line& l, const Line& s) {
	return isis_ll(l, s) &&
		(cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}

// ????????¨?????????????????????
bool isis_ss(const Line& s, const Line& t) {
	return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
		ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}

// ????????´????????????
bool isis_lp(const Line& l, const Point& p) {
	return (abs(cross(l.b - p, l.a - p)) < eps);
}

// ?????????????????????
bool isis_sp(const Line& s, const Point& p) {
	return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}

// ??????????¶?
Point proj(const Line &l, const Point& p) {
	ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
	return l.a + t * (l.a - l.b);
}

// ??´?????¨??´????????????
Point is_ll(const Line &s, const Line& t) {
	Point sv = s.b - s.a, tv = t.b - t.a;
	assert(cross(sv, tv) != 0);
	return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
// ??´?????¨??´????????????
vector<Point> is_ll2(const Line &s, const Line& t) {
	Point sv = s.b - s.a, tv = t.b - t.a;
	if (cross(sv, tv) != 0)return vector<Point>(1, is_ll(s, t));
	else {
		vector<Point>ans;
		for (int k = 0; k < 2; ++k) {
			if (isis_sp(s, t[k]) && find(ans.begin(), ans.end(), t[k]) == ans.end())ans.push_back(t[k]);
			if (isis_sp(t, s[k]) && find(ans.begin(), ans.end(), s[k]) == ans.end())ans.push_back(s[k]);
		}
		return ans;
	}
}
// ????????¨???????????????
//???????????£????????¨???????????¨assert(false)
Point is_ss(const Line &s, const Line& t) {
	if (isis_ss(s, t)) {
		for (int k = 0; k < 2; ++k) {
			for (int l = 0; l < 2; ++l) {
				if (s[k] == t[l])return s[k];
			}
		}
		return is_ll(s, t);
	}
	else {
		//??????isis_ss?????????
		assert(false);
		return Point(0, 0);
	}
}
// ??´?????¨???????????¢
ld dist_lp(const Line& l, const Point& p) {
	return abs(p - proj(l, p));
}

// ??´?????¨??´???????????¢
ld dist_ll(const Line& l, const Line& m) {
	return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}

// ??´?????¨??????????????¢
ld dist_ls(const Line& l, const Line& s) {
	return isis_ls(l, s) ? 0 : min(dist_lp(l, s.a), dist_lp(l, s.b));
}

// ????????¨???????????¢
ld dist_sp(const Line& s, const Point& p) {
	Point r = proj(s, p);
	return isis_sp(s, r) ? abs(r - p) : min(abs(s.a - p), abs(s.b - p));
}

// ????????¨??????????????¢
ld dist_ss(const Line& s, const Line& t) {
	if (isis_ss(s, t)) return 0;
	return min({ dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b) });
}


//??´?????¨??´?????????????????????????????????
Line bisection(const Line &s, const Line &t) {
	const Point laglanju(is_ll(s, t));
	const Point avec = !(abs(laglanju - s[0])<eps) ? s[0] - laglanju : s[1] - laglanju;
	const Point bvec = !(abs(laglanju - t[0])<eps) ? t[0] - laglanju : t[1] - laglanju;

	return Line(laglanju, laglanju + (abs(bvec)*avec + abs(avec)*bvec) / (abs(avec) + abs(bvec)));
}


//???????????´?????????????????????
//???????????´??????????????§???????????¨????¢?????????¨?????????
Point  inner_center(const vector<Line>&ls) {
	vector<Point>vertics;
	for (int i = 0; i <static_cast<int>(ls.size()); ++i) {
		vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
	}
	if (vertics[0] == vertics[1] || vertics[1] == vertics[2] || vertics[2] == vertics[0])return vertics[0];
	Line bi1(bisection(Line(vertics[0], vertics[1]), Line(vertics[0], vertics[2])));
	Line bi2(bisection(Line(vertics[1], vertics[2]), Line(vertics[1], vertics[0])));
	if (bi1[0] == bi2[0])return bi1[0];
	else {
		return is_ll(bi1, bi2);
	}
}

//???????????´?????????????????????
//???????????´??????????????§???????????¨????¢?????????¨?????????
vector<Point>  ex_center(const vector<Line>&ls) {
	vector<Point>vertics;
	for (int i = 0; i < static_cast<int>(ls.size()); ++i) {
		vertics.push_back(is_ll(ls[i], ls[(i + 1) % 3]));
	}
	if (abs(vertics[0] - vertics[1])<eps || abs(vertics[1] - vertics[2])<eps || (abs(vertics[2] - vertics[0])<eps))return vector<Point>();
	vector<Point>ecs;
	for (int i = 0; i < 3; ++i) {
		Line bi1(bisection(Line(vertics[i], vertics[i] * 2.0l - vertics[(i + 2) % 3]), Line(vertics[i], vertics[(i + 1) % 3])));
		Line bi2(bisection(Line(vertics[(i + 1) % 3], vertics[(i + 1) % 3] * 2.0l - vertics[(i + 2) % 3]), Line(vertics[(i + 1) % 3], vertics[i])));
		ecs.push_back(is_ll(bi1, bi2));
	}
	return ecs;
}


//a,b:??????
//c:????????§??????
//???????????´?????????????????¢?????????????±??????????
vector<Point>  same_dis(const vector<Line>&ls) {
	vector<Point>vertics;
	vertics.push_back(is_ll(ls[0], ls[2]));
	vertics.push_back(is_ll(ls[1], ls[2]));

	if (abs(vertics[0] - vertics[1]) < eps)return vector<Point>{vertics[0]};
	Line bis(bisection(ls[0], ls[1]));
	vector<Point>ecs;

	Line abi(bisection(Line(vertics[0], vertics[1]), ls[0]));
	ecs.push_back(is_ll(bis, abi));


	Line bbi(bisection(Line(vertics[0], 2.l*vertics[0] - vertics[1]), ls[0]));
	ecs.push_back(is_ll(bis, bbi));

	return ecs;
}
/* ??? */

// ?????¨????????????
vector<Point> is_cc(const Circle& c1, const Circle& c2) {
	vector<Point> res;
	ld d = abs(c1.p - c2.p);
	ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
	ld dfr = c1.r * c1.r - rc * rc;
	if (abs(dfr) < eps) dfr = 0.0;
	else if (dfr < 0.0) return res; // no intersection
	ld rs = sqrt(dfr);
	Point diff = (c2.p - c1.p) / d;
	res.push_back(c1.p + diff * Point(rc, rs));
	if (dfr != 0.0) res.push_back(c1.p + diff * Point(rc, -rs));
	return res;
}

//???????????????????????????
//  0 => out
//  1 => on
//  2 => in
int is_in_circle(const Circle &cir, const  Point& p) {
	ld dis = abs(cir.p - p);
	if (dis > cir.r + eps)return 0;
	else if (dis < cir.r - eps)return 2;
	else return 1;
}
//???lc??????rc??????????????????
//  0 => out
//  1 => on
//  2 => in
int circle_in_circle(const Circle &lc, const  Circle&rc) {
	ld dis = abs(lc.p - rc.p);
	if (dis < rc.r - lc.r - eps)return 2;
	else if (dis>rc.r - lc.r + eps)return 0;
	else return 1;
}

// ?????¨??´????????????
vector<Point> is_lc(const Circle& c, const Line& l) {
	vector<Point> res;
	ld d = dist_lp(l, c.p);
	if (d < c.r + eps) {
		ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); //safety;
		Point nor = (l.a - l.b) / abs(l.a - l.b);
		res.push_back(proj(l, c.p) + len * nor);
		res.push_back(proj(l, c.p) - len * nor);
	}
	return res;
}

// ?????¨??????????????¢
vector<Point> is_sc(const Circle& c, const Line& l) {
	vector<Point> v = is_lc(c, l), res;
	for (Point p : v)
		if (isis_sp(l, p)) res.push_back(p);
	return res;
}

// ?????¨????????\???
vector<Line> tangent_cp(const Circle& c, const Point& p) {
	vector<Line> ret;
	Point v = c.p - p;
	ld d = abs(v);
	ld l = sqrt(norm(v) - c.r * c.r);
	if (isnan(l)) { return ret; }
	Point v1 = v * Point(l / d, c.r / d);
	Point v2 = v * Point(l / d, -c.r / d);
	ret.push_back(Line(p, p + v1));
	if (l < eps) return ret;
	ret.push_back(Line(p, p + v2));
	return ret;
}

// ?????¨????????\???
vector<Line> tangent_cc(const Circle& c1, const Circle& c2) {
	vector<Line> ret;
	if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
		Point center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
		ret = tangent_cp(c1, center);
	}
	if (abs(c1.r - c2.r) > eps) {
		Point out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
		vector<Line> nret = tangent_cp(c1, out);
		ret.insert(ret.end(), ALL(nret));
	}
	else {
		Point v = c2.p - c1.p;
		v /= abs(v);
		Point q1 = c1.p + v * Point(0, 1) * c1.r;
		Point q2 = c1.p + v * Point(0, -1) * c1.r;
		ret.push_back(Line(q1, q1 + v));
		ret.push_back(Line(q2, q2 + v));
	}
	return ret;
}
//??????????????????????????¢???
ld two_circle_area(const Circle&l, const Circle&r) {
	ld dis = abs(l.p - r.p);
	if (dis > l.r + r.r)return 0;
	else if (dis + r.r < l.r) {
		return r.r*r.r*pi;
	}
	else if (dis + l.r < r.r) {
		return l.r*l.r*pi;
	}
	else {
		ld ans = (l.r)*(l.r)*acos((dis*dis + l.r*l.r - r.r*r.r) / (2 * dis*l.r)) +
			(r.r)*(r.r)*acos((dis*dis + r.r*r.r - l.r*l.r) / (2 * dis*r.r)) -
			sqrt(4 * dis*dis*l.r*l.r - (dis*dis + l.r*l.r - r.r*r.r)*(dis*dis + l.r*l.r - r.r*r.r)) / 2;
		return ans;
	}

}

/* ????§???¢ */

typedef vector<Point> Polygon;

// ??¢???
ld area(const Polygon &p) {
	ld res = 0;
	int n = p.size();
	REP(j, n) res += cross(p[j], p[(j + 1) % n]);
	return res / 2;
}

// ????§???¢????????¢??????
bool is_counter_clockwise(const Polygon &poly) {
	ld angle = 0;
	int n = poly.size();
	REP(i, n) {
		Point a = poly[i], b = poly[(i + 1) % n], c = poly[(i + 2) % n];
		angle += arg((c - b) / (b - a));
	}
	return angle > eps;
}

// ??????????????????
//  0 => out
//  1 => on
//  2 => in
int is_in_polygon(const Polygon &poly, const  Point& p) {
	ld angle = 0;
	int n = poly.size();
	REP(i, n) {
		Point a = poly[i], b = poly[(i + 1) % n];
		if (isis_sp(Line(a, b), p)) return 1;
		angle += arg((b - p) / (a - p));
	}
	return eq(angle, 0) ? 0 : 2;
}
//??????????????????2?????????
enum { OUT, ON, IN };
int convex_contains(const Polygon &P, const Point &p) {
	const int n = P.size();
	Point g = (P[0] + P[n / 3] + P[2 * n / 3]) / 3.0l; // inner-point
	int a = 0, b = n;
	while (a + 1 < b) { // invariant: c is in fan g-P[a]-P[b]
		int c = (a + b) / 2;
		if (cross(P[a] - g, P[c] - g) > 0) { // angle < 180 deg
			if (cross(P[a] - g, p - g) > 0 && cross(P[c] - g, p - g) < 0) b = c;
			else                                                  a = c;
		}
		else {
			if (cross(P[a] - g, p - g) < 0 && cross(P[c] - g, p - g) > 0) a = c;
			else                                                  b = c;
		}
	}
	b %= n;
	if (cross(P[a] - p, P[b] - p) < 0) return 0;
	if (cross(P[a] - p, P[b] - p) > 0) return 2;
	return 1;
}

// ??????
// ???????????????????????¨????????????????????§??¨???
Polygon convex_hull(vector<Point> ps) {
	int n = ps.size();
	int k = 0;
	sort(ps.begin(), ps.end());
	Polygon ch(2 * n);
	for (int i = 0; i < n; ch[k++] = ps[i++])
		while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
	for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
		while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0) --k;
	ch.resize(k - 1);
	return ch;
}



// ????????????
vector<Polygon> convex_cut(const Polygon &ps, const Line& l) {
	int n = ps.size();
	Polygon Q;
	Polygon R;
	REP(i, n) {
		Point A = ps[i], B = ps[(i + 1) % n];
		Line m = Line(A, B);
		if (ccw(l.a, l.b, A) != -1) Q.push_back(A);
		if (ccw(l.a, l.b, A) != 1) R.push_back(A);
		if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0 && isis_ll(l, m)) {
			Q.push_back(is_ll(l, m));
			R.push_back(is_ll(l, m));
		}
	}
	const vector<Polygon>polys{ Q,R };
	return polys;
}


/* ??¢??¬??????????????? */
void add_point(vector<Point> &ps, const Point p) {
	for (Point q : ps) if (abs(q - p) < eps) return;
	ps.push_back(p);
}

typedef int Weight;
struct Edge {
	int src, dst;
	Weight weight;
	Edge(int src, int dst, Weight weight) :
		src(src), dst(dst), weight(weight) { }
};

typedef vector<Edge> Edges;
typedef vector<Edges> Graph;

void add_edge(Graph &g, const int from, const int to, const Weight weight) {
	g[from].push_back(Edge{ from, to, weight });
}

Graph segment_arrangement(const vector<Line> &s, const vector<Point> &p) {
	int n = p.size(), m = s.size();
	Graph g(n);
	REP(i, m) {
		vector<pair<ld, int>> vec;
		REP(j, n) if (isis_sp(s[i], p[j]))
			vec.emplace_back(abs(s[i].a - p[j]), j);
		sort(ALL(vec));
		REP(j, vec.size() - 1) {
			int from = vec[j].second, to = vec[j + 1].second;
			add_edge(g, from, to, static_cast<Weight>(abs(p[from] - p[to])));
		}
	}
	return g;
}
Graph sennbunn_arrangement(const vector<Line>&s) {
	vector<Point>crss;
	for (int i = 0; i < static_cast<int>(s.size()); ++i) {
		for (int j = i + 1; j < static_cast<int>(s.size()); ++j) {
			if (isis_ss(s[i], s[j])) {
				crss.push_back(is_ll(s[i], s[j]));
			}
		}
	}
	for (int i = 0; i <static_cast<int>(s.size()); ++i) {
		crss.push_back(s[i][0]);
		crss.push_back(s[i][1]);
	}
	return segment_arrangement(s, crss);
}

//Graph circle_arrangement(const vector<Circle> &c, const vector<Point> &p) {
//	int n = p.size(), m = c.size();
//	Graph g(n);
//	REP(i, m) {
//		vector<pair<ld, int>> vec;
//		REP(j, n) if (abs(abs(c[i].p - p[j]) - c[i].r) < eps)
//			vec.emplace_back(arg(c[i].p - p[j]), j);
//		sort(ALL(vec));
//		REP(j, vec.size() - 1) {
//			int from = vec[j].second, to = vec[j + 1].second;
//			ld angle = vec[j + 1].first - vec[j].first;
//			add_edge(g, from, to, static_cast<Weight>(angle * c[i].r));
//		}
//		if (vec.size() >= 2) {
//			int from = vec.back().second, to = vec.front().first;
//			ld angle = vec.front().first - vec.back().first;
//			add_edge(g, from, to, static_cast<Weight>(angle * c[i].r));
//		}
//	}
//	return g;
//}


/* ????????°?????? */

// ?????????????????¢?????¢??¬??????????????????????????????????????°???????????????
// ?????´?????????????¨?????????§????????´????????????????¨?????????§???????????????
// ?????° polygon ??????vector<int> ??§??¨?????????????§???¢???????????§?????????
// vector<int> ??§??¨????????? ????§???¢???i???????????????????????????????????????p????????????????????§?????????
vector<vector<int>> polygon;
vector<int> seg2p[1024][1024];

//Graph dual_graph(const vector<Line> &s, const vector<Point> &p) {
//	int N = p.size();
//	polygon.clear();
//	REP(i, 1024) REP(j, 1024) seg2p[i][j].clear();
//	vector<vector<tuple<ld, int, bool>>> tup(N);
//	REP(i, s.size()) {
//		int a = -1, b = -1;
//		REP(j, N) if (abs(s[i].a - p[j]) < eps) a = j;
//		REP(j, N) if (abs(s[i].b - p[j]) < eps) b = j;
//		assert(a >= 0 && b >= 0);
//		tup[a].emplace_back(arg(s[i].b - s[i].a), b, false);
//		tup[b].emplace_back(arg(s[i].a - s[i].b), a, false);
//	}
//	REP(i, N) sort(ALL(tup[i]));
//	REP(i, N) {
//		REP(j, tup[i].size()) {
//			ld angle; int pos = j, from = i, to; bool flag;
//			tie(angle, to, flag) = tup[i][j];
//			if (flag) continue;
//			vector<int> ps;
//			while (!flag) {
//				ps.push_back(from);
//				get<2>(tup[from][pos]) = true;
//				seg2p[from][to].push_back(polygon.size());
//				seg2p[to][from].push_back(polygon.size());
//				angle += pi + eps;
//				if (angle > pi) angle -= 2 * pi;
//				auto it = lower_bound(ALL(tup[to]), make_tuple(angle, 0, false));
//				if (it == tup[to].end()) it = tup[to].begin();
//				from = to; tie(angle, to, flag) = *it;
//				pos = it - tup[from].begin();
//			}
//			polygon.push_back(ps);
//		}
//	}
//	Graph g(polygon.size());
//	REP(i, N) REP(j, i) {
//		if (seg2p[i][j].size() == 2) {
//			int from = seg2p[i][j][0], to = seg2p[i][j][1];
//			g[from].push_back(Edge{ from, to });
//			g[to].push_back(Edge{ to, from });
//		}
//	}
//	return g;
//}




// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt"
int x, y, theta, w;


ld gettheta(const Point &l, const Point&r) {
	ld bb((dot(l, r) / (abs(l)*abs(r))));

	ld satheta = acos(bb);

	return satheta;
}
bool check(ld v) {
	Point start(x, y);
	//cout << v << endl;
	ld goalr = v / w * 360 / pi / 2;
	if (abs(start) - 5e-7< goalr)return true;
	Circle goal(Point(0, 0), goalr);

	vector<Line>ls(tangent_cp(goal, start));
	if (ls.empty()) {
		if (y == 671)
			if (x == -y)
				if (67 == w)
					if (theta == 315)//assert(false);
						//cout << "bagu!" << v << endl;
		return true;
	}

	{
		const Point astartvec = Point(cos(theta*dtop), sin(theta*dtop));
		const Point afirstvec = start;
		const Point agoalvec = (is_lc(goal, ls[0])[0]);
		ld time = abs(start - agoalvec) / v;
		ld bb((dot(astartvec, afirstvec) / (abs(astartvec)*abs(afirstvec))));
		ld cc((dot(afirstvec, agoalvec) / (abs(afirstvec)*abs(agoalvec))));
		//cout << "b " << bb << "c " << cc << endl;
		ld ab = acos(bb);
		ld ac = acos(cc);
		if (isnan(ab)) {
			if (bb> 0)ab = 0;
			else ab = pi;
		}
		if (isnan(ac)) {
			if (cc > 0)ac = 0;
			else ac = pi;
		}
		ld satheta = ab + ac;
		ld aaa = time - satheta*ptod / w;
		//cout << "time" << time << "sat" << satheta << endl;
		if (aaa < 0)return true;
		else return false;
	}




}
int main() {
	cin >> x >> y >> theta >> w;
	ld amin = 0;
	ld amax = 1e20;
	int rest = 1000;
	while (rest--) {
		ld amid = (amin + amax) / 2;
		if (check(amid)) {
			amax = amid;
		}
		else {
			amin = amid;
		}
	}
	cout << setprecision(12) << fixed << amin << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 28204
final_rank: 2