////////////////////
#include <stdio.h>
#include <math.h>
#include <map>

using namespace std;

#define SIZE 10000

int sqr(int x) {
	return x * x;
}

struct Point {
	int x, y;
	bool operator<(const Point &p) const {
		if (x != p.x) return x < p.x;
		return y < p.y;
	}
	bool operator!=(const Point &p) const {
		return x != p.x || y != p.y;
	}
};

struct Line {
	Point a, b;
	bool operator<(const Line &l) const {
		if (a != l.a) return a < l.a;
		return b < l.b;
	}
};

map<Line, int> cache;

int make_query(Line line) {
	if (cache.find(line) != cache.end()) return cache[line];
	printf("%d %d %d %d\n", line.a.x, line.a.y, line.b.x, line.b.y);
	fflush(stdout);
	double res;
	scanf("%lf", &res);
	int similarity = round(res * 10);
	if (similarity == 1000) {
		exit(0);
	}
	return cache[line] = similarity;
}

int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};

int dist(Point a, Point b) {
	return sqr(a.x - b.x) + sqr(a.y - b.y);
}

int rev(int dir) {
	return (dir + 2) % 4;
}

Point normalize(Point p) {
	return {max(-SIZE, min(SIZE, p.x)), max(-SIZE, min(SIZE, p.y))};
}

Line normalize_line(Line l) {
	return {normalize(l.a), normalize(l.b)};
}

Point to_border(Point p, int dir) {
	return normalize({p.x + 2 * SIZE * dx[dir], p.y + 2 * SIZE * dy[dir]});
}

Point shift(Point p, int dir) {
	return normalize({p.x + dx[dir], p.y + dy[dir]});
}

Point middle(Point a, Point b) {
	return {(a.x + b.x) / 2, (a.y + b.y) / 2};
}

Point move_random(Point p, int dir, int dst) {
	int t = rand() % (2 * dst + 1) - dst;
	return normalize({p.x + dx[dir] * t, p.y + dy[dir] * t});
}

bool is_border(Point p) {
	return abs(p.x) == SIZE || abs(p.y) == SIZE;
}

Line move(Line line, int dir) {
	Point p1 = line.a;
	Point p2 = line.b;
	Point l = to_border(p1, rev(dir));
	Point r = p1;
	int init_sim = make_query(line);
	int rem = 10000000;
	while (dist(l, r) > 1 && --rem > 0) {
		Point mid = middle(l, r);
		if (make_query({mid, p2}) != init_sim) {
			l = mid;
		} else {
			r = mid;
		}
	}
	if (make_query({r, p2}) != init_sim) {
		p1 = r;
	} else {
		p1 = l;
	}
	int flag;
	int tries = 30;
	int side = (rand() % 2 == 0 ? dir + 1 : dir + 3) % 4;
	do {
		flag = false;
		int sim = make_query({p1, p2});
		p2 = shift(p2, dir);
		int new_sim = make_query({p1, p2});
		if (new_sim > sim) {
			flag = true;
			while (!is_border(p1) && make_query({p1, p2}) > sim) {
				p1 = shift(p1, rev(dir));
			}
			line.b = p2;
		} else if (tries > 0) {
			p2 = shift(p2, rev(dir));
			p1 = shift(p1, side);
			p1 = shift(p1, dir);
			while (!is_border(p1) && make_query({p1, p2}) == sim) {
				p1 = shift(p1, dir);
			}
			p1 = shift(p1, rev(dir));
			tries--;
			flag = true;
			p1 = normalize(p1);
		}
	} while (flag);
	return line;
}

Line find_start_line() {
	Line line = {{-7500, -7500}, {7500, 7500}};
	for (int step = 1024; step >= 1; step /= 2) {
		int flag;
		do {
			flag = false;
			int sim = make_query(line);
			for (int i = 0; i < 4; i++) {
				Line new_line = {{line.a.x + dx[i] * step, line.a.y + dy[i] * step}, line.b};
				new_line = normalize_line(new_line);
				if (make_query(new_line) > sim) {
					line = new_line;
					flag = true;
					sim = make_query(new_line);
				}
			}
			for (int i = 0; i < 4; i++) {
				Line new_line = {line.a, {line.b.x + dx[i] * step, line.b.y + dy[i] * step}};
				new_line = normalize_line(new_line);
				if (make_query(new_line) > sim) {
					line = new_line;
					flag = true;
					sim = make_query(new_line);
				}
			}
		} while (flag);
	}
	return line;
}

int main() {
	Line line = find_start_line();
	for (int i = 0; i < 1000; i++) {
		if (rand() % 2 == 0) {
			swap(line.a, line.b);
		}
		line = move(line, rand() % 4);
	}
	return 0;
}