#include <bits/stdc++.h>
#define ll long long
#define w cout
#define e endl
using namespace std;

const int N = 1e6 + 7;

void ask(int x1 , int y1 , int x2 , int y2) {
	w << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << e;
}

int main() {
	int n;
	cin >> n;
	int x1 = 1 , y1 = 1 , x2 = n , y2 = 1;
	int xx1  = -1, yy1  = -1, xx2 = -1 , yy2 = -1;
	int res;
	for(int i = 1 ; i <= n ; i ++ ) {
		ask(1 , i , n , i);
		cin >> res;
		if(res % 2) {
			if(yy1 == -1) {
				yy1 = i;
			} else {
				yy2 = i;
			}
		}
	}

	x1 = 1 , y1 = 1, x2 = 1 , y2 = n;
	for(int i = 1 ; i <= n ;i ++ ) {
		ask(i , 1 , i , n);
		cin >> res;
		if(res % 2) {
			if(xx1 == -1) {
				xx1 = i;
			} else {
				xx2 = i;
			}
		}
	}
	if(xx1 == -1) {
		int l = 1 , h = n;
		int ans;
		while(l <= h) {
			int mid = (l + h) / 2;
			ask(1 , yy1 , mid , yy1);
			cin >> res;
			if(res %2 == 1) {
				ans = mid;
				h = mid - 1;
			} else {
				l = mid + 1;
			}
		}
		cout << "! " << ans << " " << yy1 << " " << ans << " " << yy2 << endl;
	} else if(yy1 == -1) {
		int l = 1 , h =  n;
		int ans ;
		while(l <= h) {
			int mid = (l + h) / 2;
			ask(xx1 , 1 , xx1 , mid);
			cin >> res;
			if(res % 2 == 1) {
				ans = mid;
				h = mid - 1;
			} else{
				l = mid + 1;
			}
		}
		cout << "! " << xx1 << " " << ans << " " << xx2 << " " << ans << endl;
	} else {
			int ax1,ay1,ax2,ay2;
			ask(xx1 , yy1 , xx1 , yy1);
			cin >> res;
			if(res%2==1)
			{
				ax1=xx1,ay1=yy1;
				ax2=xx2,ay2=yy2;
			}
			else
			{
				ax1=xx1,ay1=yy2;
				ax2=xx2,ay2=yy1;
			}
			cout<<"! "<<ax1<<" "<<ay1<<" "<<ax2<<" "<<ay2<<endl;
	}
}


#include <bits/stdc++.h>
#define ll long long
#define w cout
#define e endl
using namespace std;

const int N = 1e6 + 7;

void ask(int x1 , int y1 , int x2 , int y2) {
	w << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << e;
}

int main() {
	int n;
	cin >> n;
	int x1 = 1 , y1 = 1 , x2 = n , y2 = 1;
	int xx1  = -1, yy1  = -1, xx2 = -1 , yy2 = -1;
	int res;
	for(int i = 1 ; i <= n ; i ++ ) {
		ask(1 , i , n , i);
		cin >> res;
		if(res % 2) {
			if(yy1 == -1) {
				yy1 = i;
			} else {
				yy2 = i;
			}
		}
	}

	x1 = 1 , y1 = 1, x2 = 1 , y2 = n;
	for(int i = 1 ; i <= n ;i ++ ) {
		ask(i , 1 , i , n);
		cin >> res;
		if(res % 2) {
			if(xx1 == -1) {
				xx1 = i;
			} else {
				xx2 = i;
			}
		}
	}
	if(xx1 == -1) {
		int l = 1 , h = n;
		int ans;
		while(l <= h) {
			int mid = (l + h) / 2;
			ask(1 , yy1 , mid , yy1);
			cin >> res;
			if(res == 1) {
				ans = mid;
				h = mid - 1;
			} else {
				l = mid + 1;
			}
		}
		cout << "! " << ans << " " << yy1 << " " << ans << " " << yy2 << endl;
	} else if(yy1 == -1) {
		int l = 1 , h =  n;
		int ans ;
		while(l <= h) {
			int mid = (l + h) / 2;
			ask(xx1 , 1 , xx1 , mid);
			cin >> res;
			if(res == 1) {
				ans = mid;
				h = mid - 1;
			} else{
				l = mid + 1;
			}
		}
		cout << "! " << xx1 << " " << ans << " " << xx2 << " " << ans << endl;
	} else {
			int ax1,ay1,ax2,ay2;
			ask(xx1 , yy1 , xx1 , yy1);
			cin >> res;
			if(res%2==1)
			{
				ax1=xx1,ay1=yy1;
				ax2=xx2,ay2=yy2;
			}
			else
			{
				ax1=xx1,ay1=yy2;
				ax2=xx2,ay2=yy1;
			}
			cout<<"! "<<ax1<<" "<<ay1<<" "<<ax2<<" "<<ay2<<endl;
	}
}


#include <bits/stdc++.h>
#define ll long long
#define w cout
#define e endl
using namespace std;

const int N = 1e6 + 7;

void ask(int x1 , int y1 , int x2 , int y2) {
	w << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << e;
}

int main() {
	int n;
	cin >> n;
	int x1 = 1 , y1 = 1 , x2 = n , y2 = 1;
	int xx1  = -1, yy1  = -1, xx2 = -1 , yy2 = -1;
	int res;
	while(y1 <= n) {
		ask(x1 , y1 , x2 , y1);
		cin >> res;
		if(res % 2) {
			if(yy1 == -1) {
				yy1 = y1;
			} else {
				yy2 = y1;
			}
		}
		y1++;
	}

	x1 = 1 , y1 = 1, x2 = 1 , y2 = n;
	while(x1 <= n) {
		ask(x1 , y1 , x1 , y2);
		cin >> res;
		if(res % 2) {
			if(xx1 == -1) {
				xx1 = x1;
			} else {
				xx2 = x1;
			}
		}
		x1++;
	}
	if(xx1 == -1) {
		int l = 1 , h = n;
		int ans;
		while(l <= h) {
			int mid = (l + h) / 2;
			ask(1 , yy1 , mid , yy1);
			cin >> res;
			if(res == 1) {
				ans = mid;
				h = mid - 1;
			} else {
				l = mid + 1;
			}
		}
		cout << "! " << ans << " " << yy1 << " " << ans << " " << yy2 << endl;
	} else if(yy1 == -1) {
		int l = 1 , h =  n;
		int ans ;
		while(l <= h) {
			int mid = (l + h) / 2;
			ask(xx1 , 1 , xx1 , mid);
			cin >> res;
			if(res == 1) {
				ans = mid;
				h = mid - 1;
			} else{
				l = mid + 1;
			}
		}
		cout << "! " << xx1 << " " << ans << " " << xx2 << " " << ans << endl;
	} else {
			int ax1,ay1,ax2,ay2;
			ask(xx1 , yy1 , xx1 , yy1);
			cin >> res;
			if(res%2==1)
			{
				ax1=xx1,ay1=yy1;
				ax2=xx2,ay2=yy2;
			}
			else
			{
				ax1=xx1,ay1=yy2;
				ax2=xx2,ay2=yy1;
			}
			cout<<"! "<<ax1<<" "<<ay1<<" "<<ax2<<" "<<ay2<<endl;
	}
}


#include <bits/stdc++.h>

#define ll long long

using namespace std;

istream &operator>>(istream &fin, vector<int> &a) {
    for (auto &i:a)
        fin >> i;
    return fin;
}

ostream &operator<<(ostream &out, vector<int> &a) {
    for (auto &i:a) {
        out << i << ' ';
    }
    return out;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2) {
    pair<int, int> result;
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    if (x1 != x2) {
        int mid = (x1 + x2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_x(mid + 1, y1, x2, y2);
        } else {
            result = solve_x(x1, y1, mid, y2);
        }
    } else {
        result = solve_y(x1, y1, x2, y2);
    }
    return result;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2) {
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    pair<int, int> result;
    if (y1 != y2) {
        int mid = (y1 + y2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << mid << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_y(x1, mid + 1, x2, y2);
        } else {
            result = solve_y(x1, y1, x2, mid);
        }
    } else {
        result = solve_x(x1, y1, x2, y2);
    }
    return result;
}

int just_x(int x1, int y1, int x2, int y2) {
    if (x1 == x2) {
        return x1;
    }
    int mid = (x1 + x2) / 2;
    cout << "! " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
    int x;
    cin >> x;
    if (x % 2 == 0) {
        return just_x(mid + 1, y1, x2, y2);
    } else {
        return just_x(x1, y1, mid, y2);
    }
}

int main() {
    srand(time(nullptr));
    int n;
    cin >> n;
    vector<int> blet1(n);
    vector<int> blet2(n);
    for (int i = 0; i < n; ++i) {
        blet1[i] = i + 1;
        blet2[i] = i + 1;
    }
    while (!blet1.empty()) {
        int i = rand() % blet1.size();
        i = blet1[i];
        swap(blet1[i], *prev(end(blet1)));
        blet1.pop_back();
        cout << "? " << 1 << ' ' << 1 << ' ' << n << ' ' << i << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_x(1, 1, n, i);
            b = solve_x(1, i + 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    while (!blet2.empty()) {
        int i = rand() % blet2.size();
        i = blet2[i];
        swap(blet2[i], *prev(end(blet2)));
        blet2.pop_back();
        cout << "? " << 1 << ' ' << 1 << ' ' << i << ' ' << n << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_y(1, 1, i, n);
            b = solve_y(i + 1, 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    return 0;
}


#include <bits/stdc++.h>

#define ll long long

using namespace std;

pair<int, int> solve_y(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2) {
    pair<int, int> result;
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    if (x1 != x2) {
        int mid = (x1 + x2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_x(mid + 1, y1, x2, y2);
        } else {
            result = solve_x(x1, y1, mid, y2);
        }
    } else {
        result = solve_y(x1, y1, x2, y2);
    }
    return result;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2) {
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    pair<int, int> result;
    if (y1 != y2) {
        int mid = (y1 + y2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << mid << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_y(x1, mid + 1, x2, y2);
        } else {
            result = solve_y(x1, y1, x2, mid);
        }
    } else {
        result = solve_x(x1, y1, x2, y2);
    }
    return result;
}

int main() {
    srand(time(nullptr));
    int n;
    cin >> n;
    vector<int> blet1(n);
    vector<int> blet2(n);
    for (int i = 0; i < n; ++i) {
        blet1[i] = i + 1;
        blet2[i] = i + 1;
    }
    while (!blet1.empty()) {
        int i = rand() % blet1.size();
        int j = blet1[i];
        swap(blet1[i], *prev(end(blet1)));
        blet1.pop_back();
        i = j;
        cout << "? " << 1 << ' ' << 1 << ' ' << n << ' ' << i << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_x(1, 1, n, i);
            b = solve_x(1, i + 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    while (!blet2.empty()) {
        int i = rand() % blet2.size();
        int j = blet2[i];
        swap(blet2[i], *prev(end(blet2)));
        blet2.pop_back();
        i = j;
        cout << "? " << 1 << ' ' << 1 << ' ' << i << ' ' << n << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_y(1, 1, i, n);
            b = solve_y(i + 1, 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    return 0;
}


#include <bits/stdc++.h>

#define ll long long

using namespace std;

istream &operator>>(istream &fin, vector<int> &a) {
    for (auto &i:a)
        fin >> i;
    return fin;
}

ostream &operator<<(ostream &out, vector<int> &a) {
    for (auto &i:a) {
        out << i << ' ';
    }
    return out;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2) {
    pair<int, int> result;
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    if (x1 != x2) {
        int mid = (x1 + x2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_x(mid + 1, y1, x2, y2);
        } else {
            result = solve_x(x1, y1, mid, y2);
        }
    } else {
        result = solve_y(x1, y1, x2, y2);
    }
    return result;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2) {
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    pair<int, int> result;
    if (y1 != y2) {
        int mid = (y1 + y2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << mid << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_y(x1, mid + 1, x2, y2);
        } else {
            result = solve_y(x1, y1, x2, mid);
        }
    } else {
        result = solve_x(x1, y1, x2, y2);
    }
    return result;
}

int just_x(int x1, int y1, int x2, int y2) {
    if (x1 == x2) {
        return x1;
    }
    int mid = (x1 + x2) / 2;
    cout << "! " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
    int x;
    cin >> x;
    if (x % 2 == 0) {
        return just_x(mid + 1, y1, x2, y2);
    } else {
        return just_x(x1, y1, mid, y2);
    }
}

int main() {
    srand(time(nullptr));
    int n;
    cin >> n;
    vector<int> blet1(n);
    vector<int> blet2(n);
    for (int i = 0; i < n; ++i) {
        blet1[i] = i + 1;
        blet2[i] = i + 1;
    }
    while (!blet1.empty()) {
        int i = rand() % blet1.size();
        int j = blet1[i];
        swap(blet1[i], *prev(end(blet1)));
        blet1.pop_back();
        i = j;
        cout << "? " << 1 << ' ' << 1 << ' ' << n << ' ' << i << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_x(1, 1, n, i);
            b = solve_x(1, i + 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    while (!blet2.empty()) {
        int i = rand() % blet2.size();
        int j = blet2[i];
        swap(blet2[i], *prev(end(blet2)));
        blet2.pop_back();
        i = j;
        cout << "? " << 1 << ' ' << 1 << ' ' << i << ' ' << n << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_y(1, 1, i, n);
            b = solve_y(i + 1, 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    return 0;
}


#include <bits/stdc++.h>

#define ll long long

using namespace std;

istream &operator>>(istream &fin, vector<int> &a) {
    for (auto &i:a)
        fin >> i;
    return fin;
}

ostream &operator<<(ostream &out, vector<int> &a) {
    for (auto &i:a) {
        out << i << ' ';
    }
    return out;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2) {
    pair<int, int> result;
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    if (x1 != x2) {
        int mid = (x1 + x2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_x(mid + 1, y1, x2, y2);
        } else {
            result = solve_x(x1, y1, mid, y2);
        }
    } else {
        result = solve_y(x1, y1, x2, y2);
    }
    return result;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2) {
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    pair<int, int> result;
    if (y1 != y2) {
        int mid = (y1 + y2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << mid << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_y(x1, mid + 1, x2, y2);
        } else {
            result = solve_y(x1, y1, x2, mid);
        }
    } else {
        result = solve_x(x1, y1, x2, y2);
    }
    return result;
}

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cout << "? " << 1 << ' ' << 1 << ' ' << n << ' ' << i << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_x(1, 1, n, i);
            b = solve_x(1, i + 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    for (int i = 1; i <= n; ++i) {
        cout << "? " << 1 << ' ' << 1 << ' ' << i << ' ' << n << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_y(1, 1, i, n);
            b = solve_y(i + 1, 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    return 0;
}


#include <bits/stdc++.h>

#define ll long long

using namespace std;

istream &operator>>(istream &fin, vector<int> &a) {
    for (auto &i:a)
        fin >> i;
    return fin;
}

ostream &operator<<(ostream &out, vector<int> &a) {
    for (auto &i:a) {
        out << i << ' ';
    }
    return out;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2);

pair<int, int> solve_x(int x1, int y1, int x2, int y2) {
    pair<int, int> result;
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    if (x1 != x2) {
        int mid = (x1 + x2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_x(mid + 1, y1, x2, y2);
        } else {
            result = solve_x(x1, y1, mid, y2);
        }
    } else {
        result = solve_y(x1, y1, x2, y2);
    }
    return result;
}

pair<int, int> solve_y(int x1, int y1, int x2, int y2) {
    if (x1 == x2 && y1 == y2)
        return {x1, y1};
    pair<int, int> result;
    if (y1 != y2) {
        int mid = (y1 + y2) / 2;
        cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << mid << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 0) {
            result = solve_y(x1, mid + 1, x2, y2);
        } else {
            result = solve_y(x1, y1, x2, mid);
        }
    } else {
        result = solve_x(x1, y1, x2, y2);
    }
    return result;
}

int just_x(int x1, int y1, int x2, int y2) {
    if (x1 == x2) {
        return x1;
    }
    int mid = (x1 + x2) / 2;
    cout << "! " << x1 << ' ' << y1 << ' ' << mid << ' ' << y2 << endl << flush;
    int x;
    cin >> x;
    if (x % 2 == 0) {
        return just_x(mid + 1, y1, x2, y2);
    } else {
        return just_x(x1, y1, mid, y2);
    }
}

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cout << "? " << 1 << ' ' << 1 << ' ' << n << ' ' << i << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_x(1, 1, n, i);
            b = solve_x(1, i + 1, n, n);
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    for (int i = 1; i <= n; ++i) {
        cout << "? " << 1 << ' ' << 1 << ' ' << i << ' ' << n << endl << flush;
        int x;
        cin >> x;
        if (x % 2 == 1) {
            pair<int, int> a, b;
            a = solve_y(1, 1, i, n);
            int b_x = just_x(i + 1, 1, n, n);
            b = {b_x, a.second};
            cout << "! " << a.first << ' ' << a.second << ' ' << b.first << ' ' << b.second << endl << flush;
            return 0;
        }
    }
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int n;

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

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

bool is_tail(int x, int y) {
	return ask(x, y, x, y) == 1;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if (x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (x1 == x2) {
		if (ask(x1, y1, x1, my) % 2 == 1) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if (y1 == y2) {
		if (ask(x1, y1, mx, y1) % 2 == 1) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	cin >> n;
	vector<int> a, b;
	for (int i = 1; i <= n; i++) {
		if (ask(i, 1, i, n) % 2 == 1) a.push_back(i);
		if (ask(1, i, n, i) % 2 == 1) b.push_back(i);
	}
	vector<pair<int, int>> ans;

	if (a.size() == 0) {
		ans.emplace_back(find(1, b[0], n, b[0]));
		ans.emplace_back(find(1, b[1], n, b[1]));
	}
	if (b.size() == 0) {
		ans.emplace_back(find(a[0], 1, a[0], n));
		ans.emplace_back(find(a[1], 1, a[1], n));
	}

	if (ans.empty()) {
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				if (is_tail(a[i], b[j])) ans.emplace_back(a[i], b[j]);
			}
		}
	}

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int n;

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

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

bool is_tail(int x, int y) {
	return ask(x, y, x, y) == 1;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if (x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (x1 == x2) {
		if (ask(x1, y1, x1, my) % 2 == 1) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if (y1 == y2) {
		if (ask(x1, y1, mx, y1) % 2 == 1) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	cin >> n;
	vector<int> a, b;
	for (int i = 1; i <= n; i++) {
		if (ask(i, 1, i, n) % 2 == 1) a.push_back(i);
		if (ask(1, i, n, i) % 2 == 1) b.push_back(i);
	}
	vector<pair<int, int>> ans;

	if (a.size() == 0) {
		ans.emplace_back(find(1, b[0], n, b[0]));
		ans.emplace_back(find(1, b[1], n, b[1]));
	}
	if (b.size() == 0) {
		ans.emplace_back(find(a[0], 1, a[0], n));
		ans.emplace_back(find(a[1], 1, a[1], n));
	}

	if (ans.empty()) {
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				if (is_tail(a[i], b[j])) ans.emplace_back(a[i], b[j]);
			}
		}
	}

	assert(ans.size() == 2);

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int cnt = 0;

int ask(int x1, int y1, int x2, int y2) {
	cnt++;
	if(cnt == 2019) {
		cnt /= 0;
		exit(0);
	}
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if(x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if(x1 == x2) {
		if(ask(x1, y1, x1, my)) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if(y1 == y2) {
		if(ask(x1, y1, mx, y1)) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	int n;
	cin >> n;
	vector<pair<int, int>> ans;
	if (ask(1, 1, n / 2, n / 2) % 2 == 1) ans.emplace_back(find(1, 1, n / 2, n / 2));
	if (ask(1, n / 2 + 1, n / 2, n) % 2 == 1) ans.emplace_back(find(1, n / 2 + 1, n / 2, n));
	if (ask(n / 2 + 1, 1, n, n / 2) % 2 == 1) ans.emplace_back(find(n / 2 + 1, 1, n, n / 2));
	if (ask(n/2 + 1, n/2 + 1, n, n) % 2 == 1) ans.emplace_back(find(n/2 + 1, n/2 + 1, n, n));

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if(x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	int n;
	cin >> n;
	vector<pair<int, int>> ans;
	if (ask(1, 1, n / 2, n / 2) % 2 == 1) ans.emplace_back(find(1, 1, n / 2, n / 2));
	if (ask(1, n / 2 + 1, n / 2, n) % 2 == 1) ans.emplace_back(find(1, n / 2 + 1, n / 2, n));
	if (ask(n / 2 + 1, 1, n, n / 2) % 2 == 1) ans.emplace_back(find(n / 2 + 1, 1, n, n / 2));
	if (ask(n/2 + 1, n/2 + 1, n, n) % 2 == 1) ans.emplace_back(find(n/2 + 1, n/2 + 1, n, n));

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

vector<pair<int, int>> ans;

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if (x1 == x2 && y1 == y2) return ans.emplace_back(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (x1 == x2) {
		if (ask(x1, y1, x1, my) % 2 == 1) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if (y1 == y2) {
		if (ask(x1, y1, mx, y1) % 2 == 1) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int c = 0;

void f(int x1, int y1, int x2, int y2) {
	if(x1 == x2 && y1 == y2) return;
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (x1 == x2) {
		if (ask(x1, y1, x1, my) % 2 == 1) c++, find(x1, y1, x1, my);
		else f(x1, y1, mx, y1);
		if (c == 2) return;
		if(ask(x1, my + 1, x1, y2) % 2 == 1) c++, find(x1, my + 1, x1, y2);
		else f(x1, my + 1, x1, y2);
		if (c == 2) return;
	}
	if (y1 == y2) {
		if (ask(x1, y1, mx, y1) % 2 == 1) c++, find(x1, y1, mx, y1);
		else f(x1, y1, mx, y1);
		if (c == 2) return;
		if (ask(mx + 1, y1, x2, y1) % 2 == 1) c++, find(mx + 1, y1, x2, y1);
		else f(mx + 1, y1, x2, y1);
		if (c == 2) return;
	}
	if (ask(x1, y1, mx, my) % 2 == 1) c++, find(x1, y1, mx, my);
	else f(x1, y1, mx, my);
	if (c == 2) return;
	if (ask(x1, my + 1, mx, y2) % 2 == 1) c++, find(x1, my + 1, mx, y2);
	else f(x1, my + 1, mx, y2);
	if (c == 2) return;
	if (ask(mx + 1, y1, x2, my) % 2 == 1) c++, find(mx + 1, y1, x2, my);
	else f(mx + 1, y1, x2, my);
	if (c == 2) return;
	if (ask(mx + 1, my + 1, x2, y2) % 2 == 1) c++, find(mx + 1, my + 1, x2, y2);
	else f(mx + 1, my + 1, x2, y2);
	if (c == 2) return;
}

int main() {
	int n;
	cin >> n;
	f(1, 1, n, n);
	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int n;

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

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

bool is_tail(int x, int y) {
	return ask(x, y, x, y) == 1;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if (x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (x1 == x2) {
		if (ask(x1, y1, x1, my)) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if (y1 == y2) {
		if (ask(x1, y1, mx, y1)) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	cin >> n;
	vector<int> a, b;
	for (int i = 1; i <= n; i++) {
		if (ask(i, 1, i, n) % 2 == 1) a.push_back(i);
		if (ask(1, i, n, i) % 2 == 1) b.push_back(i);
	}
	vector<pair<int, int>> ans;

	if (a.size() == 0) {
		ans.emplace_back(find(1, b[0], n, b[0]));
		ans.emplace_back(find(1, b[1], n, b[1]));
	}
	if (b.size() == 0) {
		ans.emplace_back(find(a[0], 1, a[0], n));
		ans.emplace_back(find(a[1], 1, a[1], n));
	}

	if (ans.empty()) {
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				if (is_tail(a[i], b[j])) ans.emplace_back(a[i], b[j]);
			}
		}
	}

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int n;

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

bool is_tail(int x, int y) {
	return ask(x, y, x, y) == 1;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if (x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (x1 == x2) {
		if (ask(x1, y1, x1, my) % 2 == 1) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if (y1 == y2) {
		if (ask(x1, y1, mx, y1) % 2 == 1) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	cin >> n;
	vector<int> a, b;
	for (int i = 1; i <= n; i++) {
		if (ask(i, 1, i, n) % 2 == 1) a.push_back(i);
		if (ask(1, i, n, i) % 2 == 1) b.push_back(i);
	}
	vector<pair<int, int>> ans;

	if (a.size() == 0) {
		auto t = find(1, b[0], n, b[0]);
		ans.emplace_back(t);
		ans.emplace_back(t.first, b[1]);
	}
	if (b.size() == 0) {
		auto t = find(a[0], 1, a[0], n);
		ans.emplace_back(t);
		ans.emplace_back(a[1], t.second);
	}

	if (ans.empty()) {
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				if (is_tail(a[i], b[j])) ans.emplace_back(a[i], b[j]);
			}
		}
	}

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if(x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if(x1 == x2) {
		if(ask(x1, y1, x1, my)) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if(y1 == y2) {
		if(ask(x1, y1, mx, y1)) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	int n;
	cin >> n;
	vector<pair<int, int>> ans;
	if (ask(1, 1, n / 2, n / 2) % 2 == 1) ans.emplace_back(find(1, 1, n / 2, n / 2));
	if (ask(1, n / 2 + 1, n / 2, n) % 2 == 1) ans.emplace_back(find(1, n / 2 + 1, n / 2, n));
	if (ask(n / 2 + 1, 1, n, n / 2) % 2 == 1) ans.emplace_back(find(n / 2 + 1, 1, n, n / 2));
	if (ask(n/2 + 1, n/2 + 1, n, n) % 2 == 1) ans.emplace_back(find(n/2 + 1, n/2 + 1, n, n));

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int n;

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << endl << flush;
	int res;
	cin >> res;
	return res;
}

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

bool is_tail(int x, int y) {
	int c = 0;
	for(int i=0; i<4; i++) {
		int nx = x + dx[i], ny = y + dy[i];
		if(nx < 1 || ny < 1 || nx > n || ny > n) continue;
		c += ask(x, y, nx, ny) % 2;
	}
	return c % 2 == 1;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if(x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if(x1 == x2) {
		if(ask(x1, y1, x1, my)) return find(x1, y1, x1, my);
		return find(x1, my + 1, x1, y2);
	}
	if(y1 == y2) {
		if(ask(x1, y1, mx, y1)) return find(x1, y1, mx, y1);
		return find(mx + 1, y1, x2, y1);
	}
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	cin >> n;
	vector<int> a, b;
	for(int i=1; i<=n; i++) {
		if(ask(i, 1, i, n) % 2 == 1) a.push_back(i);
		if(ask(1, i, n, i) % 2 == 1) b.push_back(i);
	}
	vector<pair<int, int>> ans;

	if(a.size() == 0) {
		ans.emplace_back(find(1, b[0], n, b[0]));
		ans.emplace_back(find(1, b[1], n, b[1]));
	}
	if(b.size() == 0) {
		ans.emplace_back(find(a[0], 1, a[0], n));
		ans.emplace_back(find(a[1], 1, a[1], n));
	}

	if(ans.empty()) {
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				if (is_tail(a[i], b[j])) ans.emplace_back(a[i], b[j]);
			}
		}
	}

	cout << "! " << ans;
}


#include <iostream>
#include <string>
#include <vector>
#include <climits>
#include <algorithm>
#include <iomanip>
#include <tuple>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <fstream>
#include <deque>
#include <queue>
#include <iomanip>
#include <numeric>

#define INTERACTIVE_PROB 0

using namespace std;

class Init {
public:
	Init() noexcept try {
#ifdef JAEYONG
#if INTERACTIVE_PROB == 1
		freopen("input.txt", "r", stdin);
		freopen("output.txt", "w", stdout);
#endif
#endif // JAEYONG
		ios_base::sync_with_stdio(false);
		cin.tie(nullptr);

		/// @add more codes to execute before program begins ...
	} catch (...) {
		cerr << "Init constructor threw an exception" << endl;
		terminate();
	}
} __init __attribute__((unused));

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(tuple<Tp...> &t, _Func &&func, Args &...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

template<size_t idx = 0, typename ...Tp, typename _Func, typename ...Args>
void for_each(const tuple<Tp...> &t, _Func &&func, Args &&...args) {
	if constexpr (idx < sizeof...(Tp)) {
		invoke(func, args..., get<idx>(t));
		if constexpr (idx + 1 < sizeof...(Tp)) {
			for_each<idx + 1>(t, func, args...);
		}
	}
}

///==========---------- For CP ----------==========///

#define endl "\n"
#define all(v) (v).begin(), (v).end()
#define TC int tt;cin>>tt;for(int t=1;t<=tt;t++)
#define CONCAT1(x, y) x##y
#define CONCAT(x, y) CONCAT1(x, y)
#define _ CONCAT(__,__COUNTER__)

typedef long long ll;
typedef long double ld;

template<typename T>
istream &operator>>(istream &in, vector<T> &v);

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t);

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t);

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p);

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t);

template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
	for (T &i: v) in >> i;
	return in;
}

template<typename U, typename V>
istream &operator>>(istream &in, pair<U, V> &p) { return in >> p.first >> p.second; }

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args...> &t) {
	for_each(t, [&](istream &in, auto &x) { in >> x; }, in);
	return in;
}

template<typename ...Args>
istream &operator>>(istream &in, tuple<Args &...> t) {
	tuple<Args...> p;
	in >> p;
	t = p;
	return in;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
	auto it = v.begin();
	if (!v.empty()) out << *it++;
	while (it != v.end()) out << " " << *it++;
	return out;
}

template<typename U, typename V>
ostream &operator<<(ostream &out, const pair<U, V> &p) { return out << p.first << " " << p.second; }

template<typename ...Args>
ostream &operator<<(ostream &out, const tuple<Args...> &t) {
	for_each(t, [&](ostream &out, auto &x) { out << x << " "; }, out);
	return out;
}

///==========---------- End of Pre-Code ----------==========///

int ask(int x1, int y1, int x2, int y2) {
	cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << flush;
	int res;
	cin >> res;
	return res;
}

pair<int, int> find(int x1, int y1, int x2, int y2) {
	if(x1 == x2 && y1 == y2) return make_pair(x1, y1);
	int mx = x1 + x2 >> 1;
	int my = y1 + y2 >> 1;
	if (ask(x1, y1, mx, my) % 2 == 1) return find(x1, y1, mx, my);
	if (ask(x1, my + 1, mx, y2) % 2 == 1) return find(x1, my + 1, mx, y2);
	if (ask(mx + 1, y1, x2, my) % 2 == 1) return find(mx + 1, y1, x2, my);
	return find(mx + 1, my + 1, x2, y2);
}

int main() {
	int n;
	cin >> n;
	vector<pair<int, int>> ans;
	if (ask(1, 1, n / 2, n / 2) % 2 == 1) ans.emplace_back(find(1, 1, n / 2, n / 2));
	if (ask(1, n / 2 + 1, n / 2, n) % 2 == 1) ans.emplace_back(find(1, n / 2 + 1, n / 2, n));
	if (ask(n / 2 + 1, 1, n, n / 2) % 2 == 1) ans.emplace_back(find(n / 2 + 1, 1, n, n / 2));
	if (ask(n/2 + 1, n/2 + 1, n, n) % 2 == 1) ans.emplace_back(find(n/2 + 1, n/2 + 1, n, n));

	cout << "! " << ans;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[2][2];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h, num;
vector<pair<int, int>>vec;
bool query(int x1, int y1, int x2, int y2) {
	cout << "?" << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
	cout.flush();
	cin >> num;
	return num % 2 == 1;
}

void findx(int x, int l, int r) {
	if (l == r) {
		if (query(x, l, x, r)) {
			pair<int, int> p;
			p.first = x, p.second = l;
			vec.push_back(p);
		}
		return;
	}
	int mid = l + r >> 1;
	if (query(x, l, x, mid)) findx(x, l, mid);
	else findx(x, mid + 1, r);
}

void findy(int y, int l, int r) {
	if (l == r) {
		pair<int, int> p;
		p.first = l, p.second = y;
		vec.push_back(p);
		return;
	}
	int mid = l + r >> 1;
	if (query(l, y, mid, y)) findy(y, l, mid);
	else findy(y, mid + 1, r);
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 1; i <= n; i++)
		if (query(i, 1, i, n))
			findx(i, 1, n);
	if (vec.empty()) {
		for (int i = 1; i <= n; i++) {
			if (query(1, i, n, i)) {
				findy(i, 1, n);
				int v = vec.front().first;
				findx(v, i + 1, n);
				break;
			}
		}
	}
	cout << "!";
	for (i = 0; i < vec.size(); i++) {
		cout << ' ' << vec[i].first << ' ' << vec[i].second;
	}
	fflush(stdout);
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[1005][1005];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
		if (j > 2)break;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
		if (j > 2)break;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
		cout.flush();
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
			cout.flush();
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
			cout.flush();
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[2][2];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
		if (j > 2)break;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
		if (j > 2)break;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
		cout.flush();
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
			cout.flush();
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
			cout.flush();
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[1005][1005];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
		if (j > 2)break;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
		if (j > 2)break;
	}
	if (j)sig++;
	j = 0;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
		cout.flush();
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
			cout.flush();
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
			cout.flush();
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[1005][1005];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
		cout.flush();
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
			cout.flush();
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
			cout.flush();
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[1005][1005];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h, num;
vector<pair<int, int>>vec;
bool query(int x1, int y1, int x2, int y2) {
	cout << "?" << ' ' << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
	cout.flush();
	cin >> num;
	return num % 2 == 1;
}

void findx(int x, int l, int r) {
	if (l == r) {
		if (query(x, l, x, r)) {
			pair<int, int> p;
			p.first = x, p.second = l;
			vec.push_back(p);
		}
		return;
	}
	int mid = l + r >> 1;
	if (query(x, l, x, mid)) findx(x, l, mid);
	else findx(x, mid + 1, r);
}

void findy(int y, int l, int r) {
	if (l == r) {
		pair<int, int> p;
		p.first = l, p.second = y;
		vec.push_back(p);
		return;
	}
	int mid = l + r >> 1;
	if (query(l, y, mid, y)) findy(y, l, mid);
	else findy(y, mid + 1, r);
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	for (int i = 1; i <= n; i++) {
		if (query(i, 1, i, n)) findx(i, 1, n);
	}
	if (vec.empty()) {
		for (int i = 1; i <= n; i++) {
			if (query(1, i, n, i)) {
				findy(i, 1, n);
				int v = vec.front().first;
				if (i == 1 || !query(v, 1, v, i - 1)) findx(v, i + 1, n);
				else findx(v, 1, i - 1);
				break;
			}
		}
	}
	cout << "!";
	for (i = 0; i < vec.size(); i++) {
		cout << ' ' << vec[i].first << ' ' << vec[i].second;
	}
	fflush(stdout);
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[2][2];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 1) {
				mid = (r + l) / 2;
				cout << l << ' ' << 1 << ' ' << mid << ' ' << 1 << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
		}
		else {
			l = 1, r = n;
			while (r - l > 1) {
				mid = (r + l) / 2;
				cout << 1 << ' ' << l << ' ' << 1 << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[2][2];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
		cout.flush();
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << a[0][0] << ' ' << l << ' ' << a[0][0] << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
			cout.flush();
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << a[0][1] << ' ' << mid << ' ' << a[0][1] << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
			cout.flush();
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[2][2];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << 1 << ' ' << mid << ' ' << 1 << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
		}
		else {
			l = 1, r = n;
			while (r - l > 0) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << 1 << ' ' << l << ' ' << 1 << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<string>
#include<iomanip>
#include<queue>
#include<stdlib.h>
typedef long long ll;
#define INF 0x3f3f3f3f
#define SIZE 200007
#define pi acos(-1.0)
#define forn for(i = 0; i < n; i++)
#define read(a, n) for (i = 0; i < n; i++) cin >> a[i];
#define ms(a, n) memset(a, n, sizeof(a));
using namespace std;
ll n, m, k, t, i, j, sig = 0, h;
int a[2][2];
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin >> n;
	ms(a, 0);
	int x1, y1, x2, y2, num;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << i << ' ' << 1 << ' ' << i << ' ' << n << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][0] = i;
	}
	if (j)sig++;
	j = 0;
	for (i = 1; i <= n; i++) {
		cout << "?" << ' ' << 1 << ' ' << i << ' ' << n << ' ' << i << endl;
		cout.flush();
		cin >> num;
		if (num % 2)a[j++][1] = i;
	}
	if (j)sig++;
	if (sig == 2) {
		cout << "!" << ' ' << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
	}
	else {
		int l, r, mid;
		if (a[0][0]) {
			l = 1, r = n;
			while (r - l > 1) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << l << ' ' << 1 << ' ' << mid << ' ' << 1 << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << a[0][0] << ' ' << l << ' ' << a[1][0] << ' ' << l << endl;
		}
		else {
			l = 1, r = n;
			while (r - l > 1) {
				mid = (r + l) / 2;
				cout << "?" << ' ' << 1 << ' ' << l << ' ' << 1 << ' ' << mid << endl;
				cout.flush();
				cin >> num;
				if (num % 2)r = mid;
				else l = mid + 1;
			}
			cout << "!" << ' ' << l << ' ' << a[0][1] << ' ' << l << ' ' << a[1][1] << endl;
		}
	}
	return 0;
}


// Author: Tyler Wang

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <new>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

using namespace std;

template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << '{' << p.first << ", " << p.second << '}';
}

template <
    typename Container, typename = typename Container::const_iterator,
    typename = std::enable_if_t<!std::is_same_v<Container, std::string> &&
                                !std::is_same_v<Container, std::string_view>>>
std::ostream& operator<<(std::ostream& os, const Container& c) {
  os << '{';
  for (auto it = c.begin(); it != c.end(); ++it) {
    if (it != c.begin()) {
      os << ", ";
    }
    os << *it;
  }
  return os << '}';
}

namespace debug_internal {

template <typename T>
void print(std::string_view name, const T& val) {
  std::cerr << name << " = " << val << std::endl;
}

template <typename T1, typename... Ts>
void print(std::string_view names, const T1& val1, const Ts&... vals) {
  for (int i = 0, paren = 0; i < (int)names.size(); ++i) {
    if (names[i] == '(' || names[i] == '{') {
      ++paren;
    } else if (names[i] == ')' || names[i] == '}') {
      --paren;
    } else if (names[i] == ',' && paren == 0) {
      std::cerr << names.substr(0, i) << " = " << val1 << ',';
      return print(names.substr(i + 1), vals...);
    }
  }
}

}  // namespace debug_internal

#define debug(...) debug_internal::print(#__VA_ARGS__, __VA_ARGS__)

int query(int x1, int x2, int y1, int y2) {
  cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
  int res;
  cin >> res;
  return res;
}

void answer(int x1, int x2, int y1, int y2) {
  cout << "! " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.precision(12);
  std::cerr.precision(12);
  auto start_time = std::chrono::steady_clock::now();
  std::mt19937 rng((std::uint_fast32_t)start_time.time_since_epoch().count());
  int n;
  cin >> n;
  vector<int> xs, ys;
  for (int i = 1; i <= n; ++i) {
    if (query(i, i, 1, n) & 1) {
      xs.push_back(i);
    }
  }
  for (int i = 1; i <= n; ++i) {
    if (query(1, n, i, i) & 1) {
      ys.push_back(i);
    }
  }
  if (!xs.empty() && !ys.empty()) {
    if (query(xs[0], xs[0], ys[0], ys[0]) == 1) {
      answer(xs[0], xs[1], ys[0], ys[1]);
    } else {
      answer(xs[0], xs[1], ys[1], ys[0]);
    }
  } else if (ys.empty()) {
    int low = 1, high = n;
    while (low < high) {
      int mid = (low + high) / 2;
      if (query(xs[0], xs[0], low, mid) == 1) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }
    answer(xs[0], xs[1], low, low);
  } else {
    assert(xs.empty());
    int low = 1, high = n;
    while (low < high) {
      int mid = (low + high) / 2;
      if (query(low, mid, ys[0], ys[0]) == 1) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }
    answer(low, low, ys[0], ys[1]);
  }
#ifdef TYLER
  std::cerr << "time = "
            << std::chrono::duration_cast<std::chrono::milliseconds>(
                   std::chrono::steady_clock::now() - start_time)
                   .count()
            << " ms" << std::endl;
#endif
  return 0;
}


// Author: Tyler Wang

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <new>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

using namespace std;

template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << '{' << p.first << ", " << p.second << '}';
}

template <
    typename Container, typename = typename Container::const_iterator,
    typename = std::enable_if_t<!std::is_same_v<Container, std::string> &&
                                !std::is_same_v<Container, std::string_view>>>
std::ostream& operator<<(std::ostream& os, const Container& c) {
  os << '{';
  for (auto it = c.begin(); it != c.end(); ++it) {
    if (it != c.begin()) {
      os << ", ";
    }
    os << *it;
  }
  return os << '}';
}

namespace debug_internal {

template <typename T>
void print(std::string_view name, const T& val) {
  std::cerr << name << " = " << val << std::endl;
}

template <typename T1, typename... Ts>
void print(std::string_view names, const T1& val1, const Ts&... vals) {
  for (int i = 0, paren = 0; i < (int)names.size(); ++i) {
    if (names[i] == '(' || names[i] == '{') {
      ++paren;
    } else if (names[i] == ')' || names[i] == '}') {
      --paren;
    } else if (names[i] == ',' && paren == 0) {
      std::cerr << names.substr(0, i) << " = " << val1 << ',';
      return print(names.substr(i + 1), vals...);
    }
  }
}

}  // namespace debug_internal

#define debug(...) debug_internal::print(#__VA_ARGS__, __VA_ARGS__)

int query(int x1, int x2, int y1, int y2) {
  cout << "? " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
  int res;
  cin >> res;
  return res;
}

void answer(int x1, int x2, int y1, int y2) {
  cout << "! " << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.precision(12);
  std::cerr.precision(12);
  auto start_time = std::chrono::steady_clock::now();
  std::mt19937 rng((std::uint_fast32_t)start_time.time_since_epoch().count());
  int n;
  cin >> n;
  debug(n);
  vector<int> xs, ys;
  for (int i = 1; i <= n; ++i) {
    if (query(i, i, 1, n) & 1) {
      xs.push_back(i);
    }
  }
  for (int i = 1; i <= n; ++i) {
    if (query(1, n, i, i) & 1) {
      ys.push_back(i);
    }
  }
  debug(xs);
  debug(ys);
  if (!xs.empty() && !ys.empty()) {
    if (query(xs[0], xs[0], ys[0], ys[0]) == 1) {
      answer(xs[0], xs[1], ys[0], ys[1]);
    } else {
      answer(xs[0], xs[1], ys[1], ys[0]);
    }
  } else if (ys.empty()) {
    int low = 1, high = n;
    while (low < high) {
      int mid = (low + high) / 2;
      if (query(xs[0], xs[0], low, mid) == 1) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }
    answer(xs[0], xs[1], low, low);
  } else {
    assert(xs.empty());
    int low = 1, high = n;
    while (low < high) {
      int mid = (low + high) / 2;
      if (query(low, mid, ys[0], ys[0]) == 1) {
        high = mid;
      } else {
        low = mid + 1;
      }
    }
    answer(low, low, ys[0], ys[1]);
  }
#ifdef TYLER
  std::cerr << "time = "
            << std::chrono::duration_cast<std::chrono::milliseconds>(
                   std::chrono::steady_clock::now() - start_time)
                   .count()
            << " ms" << std::endl;
#endif
  return 0;
}


#include <algorithm>
#include <cassert>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int N;
int query(int u, int d, int l, int r) {
  printf("? %d %d %d %d\n", u, l, d, r);
  fflush(stdout);
  int x;
  scanf("%d", &x);
  return x;
}
int main() {
  scanf("%d", &N);
  std::vector<int> ox, oy;
  for (int i = 1; i <= N; i++)
    if (query(i, i, 1, N) % 2 == 1) ox.push_back(i);
  for (int i = 1; i <= N; i++)
    if (query(1, N, i, i) % 2 == 1) oy.push_back(i);
  if (ox.empty()) {
    assert(oy.size() == 2);
    int l = 1, r = N;
    while (l < r) {
      int m = l + r >> 1;
      if (query(l, m, oy[0], oy[0]) % 2 == 1)
        r = m;
      else
        l = m + 1;
    }
    printf("! %d %d %d %d\n", l, oy[0], l, oy[1]);
    fflush(stdout);
    return 0;
  }
  if (oy.empty()) {
    assert(ox.size() == 2);
    int l = 1, r = N;
    while (l < r) {
      int m = l + r >> 1;
      if (query(ox[0], ox[0], l, m) % 2 == 1)
        r = m;
      else
        l = m + 1;
    }
    printf("! %d %d %d %d\n", ox[0], l, ox[1], l);
    fflush(stdout);
    return 0;
  }
  if (N == 999) {
    for (int i : ox) {
      cerr << i << ' ';
    }
    cerr << endl;
    for (int i : oy) {
      cerr << i << ' ';
    }
    cerr << endl;
  }
  if (query(ox[0], ox[0], oy[0], oy[0]) % 2 == 1)
    printf("! %d %d %d %d\n", ox[0], oy[0], ox[1], oy[1]);
  else
    printf("! %d %d %d %d\n", ox[0], oy[1], ox[1], oy[0]);
  fflush(stdout);
  return 0;
}