#include <iostream>
#include <bits/stdc++.h>

using namespace std;
typedef long long int ll;

#define x first
#define y second

vector<int> parent;

int find(int v){
    if (parent[v] == v){
        return v;

    }
    int k = find(parent[v]);
    parent[v] = k;
    return k;
}

bool Union(int v, int w){
    int pv = find(v);
    int pw = find(w);
    if (pv != pw){
        parent[pv] = pw;
        return false;
    }
    return true;
}

int main(){
    ll n, x1, y1, x2, y2, i1, i2, answer = 3;

    cin >> n;
    map<pair<int, int>, int> pointToI;
    vector<pair<int, int>> vertices;
    vector<vector<int>> iedges(2*n);
    set<tuple<int, int, int, int>> edges;
    vector<pair<int, int>> iEdgeList;
    for (int i=0; i<n; i++){
        cin >> x1 >> y1 >> x2 >> y2;
        edges.emplace(x1, y1, x2, y2);
        edges.emplace(x2, y2, x1, y1);
        if (pointToI.count({x1, y1})) {
            i1 = pointToI[{x1, y1}];
        }
        else {
            i1 = pointToI[{x1, y1}] = pointToI.size();
            vertices.emplace_back(x1, y1);
        }
        if (pointToI.count({x2, y2})) {
            i2 = pointToI[{x2, y2}];
        }
        else {
            i2 = pointToI[{x2, y2}] = pointToI.size();
            vertices.emplace_back(x2, y2);
        }
        iedges[i1].push_back(i2);
        iedges[i2].push_back(i1);
        iEdgeList.emplace_back(i1, i2);
    }

    int v = pointToI.size();

    for (int i=0; i<v && answer == 3; i++){
        for (int s1: iedges[i]){
            for (int s2: iedges[i]) {
                if ((vertices[s1].x - vertices[s2].x) * (vertices[s1].x - vertices[s2].x) + (vertices[s1].y - vertices[s2].y) * (vertices[s1].y - vertices[s2].y) == 2){
                    answer = 2;
                    break;
                }
            }
        }
    }
    if (answer == 3) {
        for (auto &[x1, y1, x2, y2]: edges) {
            if (x1 == x2) {
                if (edges.count({x1 + 1, y1, x2 + 1, y2}) || edges.count({x1 - 1, y1, x2 - 1, y2})) {
                    answer = 2;
                    break;
                }
            }
            else {
                if (edges.count({x1, y1 + 1, x2, y2 + 1}) || edges.count({x1, y1 - 1, x2, y2 - 1})) {
                    answer = 2;
                    break;
                }
            }
        }
    }

    parent.resize(v);
    for (int i=0; i<v; i++){
        parent[i] = i;
    }
    for (auto [u, v]: iEdgeList) {
        if (Union(u, v)) {
            answer = 0;
        }
    }
    if (answer >= 2){
        for (int i=0; i<v && answer >= 2; i++){
            auto [x, y] = vertices[i];
            int DR [] = {1, 0, -1, 0};
            int DC [] = {0, 1, 0, -1};
            for (int dd=0; dd<4; dd++){
                ll x2 = x + DR[dd];
                ll y2 = y + DC[dd];
                auto it = pointToI.find({x2, y2});
                if (it != pointToI.end() && std::find(iedges[i].begin(), iedges[i].end(), it->second) == iedges[i].end() && find(i) == find(it->second)) {
                    answer = 1;
                }
            }
        }
    }

    cout << answer << '\n';
}