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 <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
static const double eps = 1e-10;
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

bool equals(double a, double b)
{
	return(fabs(a - b) < eps);
}

class Point
{
public:
	double x, y;
	Point(double x = 0, double y = 0) : x(x), y(y){}

	Point operator + (Point p){ return(Point(x + p.x, y + p.y)); }
	Point operator - (Point p){ return(Point(x - p.x, y - p.y)); }
	Point operator * (double a){ return(Point(a * x, a * y)); }
	Point operator / (double a){ return(Point(x / a, y / a)); }

	double abs(){ return(sqrt(norm())); }
	double norm(){ return(x * x + y * y); }

	bool operator < (const Point& p) const
	{
		return(x != p.x ? x < p.x : y < p.y);
	}

	bool operator == (const Point& p) const
	{
		return(fabs(x - p.x) < eps && fabs(y - p.y) < eps);
	}
};
typedef Point Vector;


struct Segment
{
	Point p1, p2;
};
typedef Segment Line;

class Circle
{
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) : c(c), r(r){}
};

double dot(Vector a, Vector b)
{
	return(a.x * b.x + a.y * b.y);
}

double cross(Vector a, Vector b)
{
	return(a.x * b.y - a.y * b.x);
}

Point project(Segment s, Point p)
{
	Vector base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / base.norm();
	return(s.p1 + base * r);
}

Point reflect(Segment s, Point p)
{
	return(p + (project(s, p) - p) * 2.0);
}

bool isOrthogonal(Vector a, Vector b)
{
	return(equals(dot(a, b), 0.0));
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2)
{
	return(isOrthogonal(a1 - a2, b1 - b2));
}

bool isOrthogonal(Segment s1, Segment s2)
{
	return(equals(dot(s1.p2 - s2.p1, s2.p2 - s2.p1), 0.0));
}

bool isParallel(Vector a, Vector b)
{
	return(equals(cross(a, b), 0.0));
}

bool isParallel(Point a1, Point a2, Point b1, Point b2)
{
	return(isParallel(a1 - a2, b1 - b2));
}

bool isParallel(Segment s1, Segment s2)
{
	return(equals(cross(s1.p1 - s1.p1, s2.p2 - s2.p1), 0.0));
}

int ccw(Point p0, Point p1, Point p2)
{
	Vector a = p1 - p0;
	Vector b = p2 - p0;
	if (cross(a, b) > eps)
	{
		return(COUNTER_CLOCKWISE);
	}
	if (cross(a, b) < -eps)
	{
		return(CLOCKWISE);
	}
	if (dot(a, b) < -eps)
	{
		return(ONLINE_BACK);
	}
	if (a.norm() < b.norm())
	{
		return(ONLINE_FRONT);
	}
	return(ON_SEGMENT);
}

bool intersect(Point p1, Point p2, Point p3, Point p4)
{
	return(ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}

bool intersect(Segment s1, Segment s2)
{
	return(intersect(s1.p1, s1.p2, s2.p1, s2.p2));
}

double getDistance(Point a, Point b)
{
	return((a - b).abs());
}

double getDistanceLP(Line l, Point p)
{
	return(abs((cross(l.p2 - l.p1, p - l.p1) / (l.p2 - l.p1).abs())));
}

double getDistanceSP(Segment s, Point p)
{
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
	{
		return((p - s.p1).abs());
	}
	if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
	{
		return((p - s.p2).abs());
	}
	return(getDistanceLP(s, p));
}

double getDistance(Segment s1, Segment s2)
{
	if (intersect(s1, s2))
	{
		return(0.0);
	}
	return(min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)), min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))));
}

Point getCrossPoint(Segment s1, Segment s2)
{
	Vector base = s2.p2 - s2.p1;
	double d1 = abs(cross(base, s1.p1 - s2.p1));
	double d2 = abs(cross(base, s1.p2 - s2.p1));
	double t = d1 / (d1 + d2);
	return(s1.p1 + (s1.p2 - s1.p1) * t);
}

pair<Point, Point> getCrossPoints(Circle c, Line l)
{
	Vector pr = project(l, c.c);
	Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
	double base = sqrt(c.r * c.r - (pr - c.c).norm());
	return(make_pair(pr - e * base, pr + e * base));
}

void solve()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	Circle circle;
	cin >> circle.c.x >> circle.c.y >> circle.r;
	int q;
	cin >> q;
	for (int i = 0; i < q; ++i)
	{
		Line line;
		cin >> line.p1.x >> line.p1.y >> line.p2.x >> line.p2.y;
		pair<Point, Point> pp = getCrossPoints(circle, line);
		if (pp.first < pp.second)
		{
			printf("%.10f %.10f %.10f %.10f\n", pp.first.x, pp.first.y, pp.second.x, pp.second.y);
		}
		else
		{
			printf("%.10f %.10f %.10f %.10f\n", pp.second.x, pp.second.y, pp.first.x, pp.first.y);
		}
	}
}

int main()
{
	solve();
	return(0);
}