#include<bits/stdc++.h>

#define EQ(a,b) (abs((a)-(b)) < EPS)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define fs first
#define sc second
#define pb push_back
#define sz size()
#define all(a) (a).begin(),(a).end()
using namespace std;
typedef long double D;
typedef complex<D> P;
typedef pair<P,P> L;
typedef vector<P> Poly;

const D EPS = 1e-12;
const D PI = acos(-1);

inline D dot(P x, P y){return real(conj(x)*y);}
inline D cross(P x, P y){return imag(conj(x)*y);}
inline P rotate(P v, D s){
  return P(real(v)*cos(s) - imag(v)*sin(s), real(v)*sin(s) + imag(v)*cos(s) );
}

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

inline P line_cp(L a,L b){
  return a.fs+(a.sc-a.fs)*cross(b.sc-b.fs,b.fs-a.fs)/cross(b.sc-b.fs,a.sc-a.fs);
}

//vertexes are in the counter-clockwise order.
inline Poly convex_cut(Poly p,L l){
  Poly res;
  rep(i,p.sz){
    int nxt = (i+1)%p.sz;
    if(ccw(l.fs,l.sc,p[i]) != -1)res.pb(p[i]);
    if(ccw(l.fs,l.sc,p[i]) * ccw(l.fs,l.sc,p[nxt]) < 0){
      res.pb( line_cp(l, L(p[i],p[nxt]) ) );
    }
  }
  return res;
}

inline D area(Poly p){
  if(p.sz<3)return 0;
  D res = cross(p[p.sz-1],p[0]);
  rep(i,p.sz-1)res += cross(p[i],p[i+1]);
  return res/2;
}

inline P center(Poly p){
  P g(0,0);
  rep(i,p.sz)g += p[i];
  return 1.0L/p.sz * g;
}

int main(){
  const P unit(1,0);
  D h,w,e;
  scanf("%Lf%Lf%Lf",&w,&h,&e);
  e *= PI/180;

  if(EQ(e,0)){
    P p1 = P(w,h);
    printf("? %.12Lf %.12Lf\n", p1.real(), p1.imag()); fflush(stdout);
    D seta1;
    scanf("%Lf",&seta1);
    seta1 *= PI/180;
    L l1 = L(p1, p1+rotate(unit,seta1));

    P p2;
    if( ccw(l1.fs,l1.sc,P(-w,h)) )p2 = P(-w,h);
    else p2 = P(-w,-h);
    printf("? %.12Lf %.12Lf\n", -w, h); fflush(stdout);
    D seta2;
    scanf("%Lf",&seta2);
    seta2 *= PI/180;
    L l2 = L(p2, p2+rotate(unit,seta2));

    P g = line_cp(l1,l2);
    printf("! %.12Lf %.12Lf\n", g.real()+EPS, g.imag()+EPS); fflush(stdout);
    exit(1);
  }else{
    Poly p;
    p.pb(P(-w,-h)); p.pb(P(w,-h));
    p.pb(P(w,h));   p.pb(P(-w,h));
    
    P g;
    vector<D> vs;

    for(int cnt=0;cnt<200 && area(p)>1e-4;cnt++){
      g = center(p);
      printf("? %.12Lf %.12Lf\n", g.real(), g.imag()); fflush(stdout);

      D seta;
      scanf("%Lf",&seta);
      seta *= PI/180;

      if(e<=PI/2){
	D tl = seta-e, tr = seta+e;
	p = convex_cut(p, L(g,g+rotate(unit,tl)));
	p = convex_cut(p, L(g+rotate(unit,tr),g));
      }else{
	D tl = -2*PI, tr = 2*PI;
	vs.push_back(seta);
	rep(i,vs.sz)rep(j,i){
	  D dif = abs(vs[i]-vs[j]);
	  if(dif>PI)dif -= PI;
	  if(2*e-PI<dif && dif<2*PI-2*e){
	    if( (vs[i]-vs[j]<0) ^ (abs(vs[i]-vs[j])>PI) ){
	      tl = vs[j]-e; tr = vs[i]+e;
	    }else{
	      tl = vs[i]-e; tr = vs[j]+e;
	    }
	    while(tl<-PI)tl+=2*PI; while(tl>PI)tl-=2*PI;
	    while(tr<-PI)tr+=2*PI; while(tr>PI)tr-=2*PI;
	  }
	}
      
	if(-2*PI < tl){
	  p = convex_cut(p, L(g,g+rotate(unit,tl)));
	  p = convex_cut(p, L(g+rotate(unit,tr),g));
	  vs.clear();
	}
      }
    }
    
    g = center(p);
    printf("! %.12Lf %.12Lf\n", g.real(), g.imag()); fflush(stdout);
    exit(1);
  }
}

Measured memory_bytes: 1432