For given a circle $c$ and a line $l$, print the coordinates of the cross points of them.

Constraints

* $p1$ and $p2$ are different
* The circle and line have at least one cross point
* $1 \leq q \leq 1,000$
* $-10,000 \leq cx, cy, x1, y1, x2, y2 \leq 10,000$
* $1 \leq r \leq 10,000$

Input

The input is given in the following format.

$cx\; cy\; r$
$q$
$Line_1$
$Line_2$
:
$Line_q$


In the first line, the center coordinate of the circle and its radius are given by $cx$, $cy$ and $r$. In the second line, the number of queries $q$ is given.

In the following $q$ lines, as queries, $Line_i$ are given ($1 \leq i \leq q$) in the following format.

$x_1\; y_1\; x_2\; y_2$

Each line is represented by two points $p1$ and $p2$ which the line crosses. The coordinate of $p1$ and $p2$ are given by ($x1$, $y1$) and ($x2$, $y2$) respectively. All input values are given in integers.

Output

For each query, print the coordinates of the cross points in the following rules.

* If there is one cross point, print two coordinates with the same values.
* 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.000001.

Example

Input

2 1 1
2
0 1 4 1
3 0 3 3


Output

1.00000000 1.00000000 3.00000000 1.00000000
3.00000000 1.00000000 3.00000000 1.00000000
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(a); (i)<(b); ++(i))
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef complex<double> xy_t;
typedef pair<xy_t, int> pci;
typedef vector<lint> poly;
template<class T>bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T>bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}

constexpr lint mod = 1e9+7;
constexpr lint INF = mod*mod;
constexpr int MAX = 100010;

constexpr double eps=1e-9;

inline int sgn(double x){
    if(x<-eps) return -1;
    if(x>eps) return 1;
    return 0;
}

inline bool EQ(double x, double y){
    return sgn(x-y)==0;
}

inline bool GE(double x, double y){
    return sgn(x-y)==1;
}

inline bool LE(double x, double y){
    return sgn(x-y)==-1;
}

inline bool GEQ(double x, double y){
    return sgn(x-y)>=0;
}

inline bool LEQ(double x, double y){
    return sgn(x-y)<=0;
}

struct Point{
    double x, y;
    Point(double x, double y): x(x), y(y){}

    Point operator+(const Point &p){
        return {x+p.x, y+p.y};
    }

    Point operator-(const Point &p){
        return {x-p.x, y-p.y};
    }

    Point operator*(const double k){
        return {k*x, k*y};
    }

    Point operator/(const double k){
        return {x/k, y/k};
    }

    double operator*(const Point &p){
        return x*p.x+y*p.y;
    }

    double operator^(const Point &p){
        return x*p.y-y*p.x;
    }

    bool operator==(const Point &p){
        return EQ(x, p.x) && EQ(y, p.y);
    }
};

using Vec=Point;
using Polygon=vector<Point>;

double norm(Point p){
    return p.x*p.x+p.y*p.y;
}

double abs(Point p){
    return sqrt(norm(p));
}

double arg(Point p){
    return atan2(p.y, p.x);
}

Point proj(Point a, Vec v, Point p){
    double t=v*(p-a)/norm(v);
    return a+v*t;
}

Point refl(Point a, Vec v, Point p){
    return proj(a, v, p)*2-p;
}

constexpr int CCW_COUNTER_CLOCKWISE=1;
constexpr int CCW_CLOCKWISE=-1;
constexpr int CCW_ONLINE_BACK=-2;
constexpr int CCW_ONLINE_FRONT=2;
constexpr int CCW_ON_SEGMENT=0;

inline int ccw(Point a, Point b, Point c){
    Vec v=b-a, w=c-a;
    if(GE(v^w, 0)) return CCW_COUNTER_CLOCKWISE;
    if(LE(v^w, 0)) return CCW_CLOCKWISE;
    if(LE(v*w, 0)) return CCW_ONLINE_BACK;
    if(LE((a-b)*(c-b), 0)) return CCW_ONLINE_FRONT;
    return CCW_ON_SEGMENT;
}

bool isParallel(Vec v, Vec w){
    return EQ(v^w, 0);
}

bool isOrthogonal(Vec v, Vec w){
    return EQ(v*w, 0);
}

bool intersectSS(Point a, Point b, Point c, Point d){
    return ccw(a, b, c)*ccw(a, b, d)<=0 && ccw(c, d, a)*ccw(c, d, b)<=0;
}

Point getCrossPointLL(Point a, Vec v, Point b, Vec w){
    double t=((b-a)^w)/(v^w);
    return a+v*t;
}

double getDistanceLP(Point a, Vec v, Point p){
    return abs(v^(p-a)/abs(v));
}

double getDistanceSP(Point a, Point b, Point p){
    if(LE((b-a)*(p-a), 0)) return abs(p-a);
    if(LE((a-b)*(p-b), 0)) return abs(p-b);
    return getDistanceLP(a, b-a, p);
}

double getDistanceLL(Point a, Vec v, Point b, Vec w){
    if(isParallel(v, w)) return getDistanceLP(a, v, b);
    return 0;
}

double getDistanceLS(Point a, Vec v, Point c, Point d){
    Point b=a+v;
    if(ccw(a, b, c)*ccw(a, b, d)<=0) return 0;
    return min(getDistanceLP(a, v, c), getDistanceLP(a, v, d));
}

double getDistanceSS(Point a, Point b, Point c, Point d){
    if(intersectSS(a, b, c, d)) return 0;
    return min({getDistanceSP(a, b, c), getDistanceSP(a, b, d),
                getDistanceSP(c, d, a), getDistanceSP(c, d, b)});
}

int intersectCC(Point c1, double r1, Point c2, double r2){
    if(r1<r2){
        swap(c1, c2);
        swap(r1, r2);
    }
    double d=abs(c1-c2), r=r1+r2;
    if(GE(d, r)) return 4;
    if(EQ(d, r)) return 3;
    if(EQ(d+r2, r1)) return 1;
    if(LE(d+r2, r1)) return 0;
    return 2;
}

bool intersectCL(Point c, double r, Point a, Vec v){
    return LEQ(getDistanceLP(a, v, c), r);
}

bool intersectCS(Point c, double r, Point a, Point b){
    return LEQ(getDistanceSP(a, b, c), r) && GEQ(max(abs(a-c), abs(b-c)), r);
}

Polygon getCrossPointCL(Point c, double r, Point a, Vec v){
    Polygon ps;
    Point p=proj(a, v, c);
    double t=sqrt(max(0.0, (r*r-norm(p-c))/norm(v)));
    ps.push_back(p+v*t);
    if(!EQ(t, 0)) ps.push_back(p-v*t);
    return ps;
}

int main(){
    double cx, cy, r;
    scanf("%lf%lf%lf", &cx, &cy, &r);
    Point c(cx, cy);
    int q;
    scanf("%d\n", &q);
    while(q--){
        double x1, y1, x2, y2;
        scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
        Point a(x1, y1), b(x2, y2);
        Polygon ps=getCrossPointCL(c, r, a, b-a);
        if(ps.size()==1){
            printf("%.20lf %.20lf %.20lf %.20lf\n", ps[0].x, ps[0].y, ps[0].x, ps[0].y);
        }
        else{
            if(EQ(ps[0].x, ps[1].x) && GE(ps[0].y, ps[1].y)) swap(ps[0], ps[1]);
            if(GE(ps[0].x, ps[1].x)) swap(ps[0], ps[1]);
            printf("%.20lf %.20lf %.20lf %.20lf\n", ps[0].x, ps[0].y, ps[1].x, ps[1].y);
        }
    }
}
