#include <iostream>
#include <algorithm>
#include <set>

#define MAX 100003
#define MAX4 400003

using namespace std;

struct Rect {
  int x1;
  int x2;
  int y1;
  int y2;
  int d;
};

enum EType
{
  eLL = 0,
  eLU = 1,
  eRL = 2,
  eRU = 3
};

struct Point
{
  int r;
  int x;
  int y;
  int d;
  EType t;
};

Rect R[MAX];
Point P[MAX4];

typedef set<int, bool(*)(const int&, const int&)> SetI;
typedef SetI::iterator SetIit;

bool CompareR(const int& a, const int& b)
{
  if (R[a].x1 != R[b].x1)
    return R[a].x1<R[b].x1;
  else if (R[a].x2 != R[b].x2)
    return R[a].x2<R[b].x2;
  if (R[a].y1 != R[b].y1)
    return R[a].y1<R[b].y1;
  else
    return R[a].y2<R[b].y2;
};

bool CompareP(const int& a, const int& b)
{
  if (P[a].x != P[b].x)
    return P[a].x<P[b].x;
  else if(P[a].t>1 && P[b].t<2)
    return 1;
  else if(P[a].t<2 && P[b].t>1)
    return 0;
  else if(P[a].y != P[b].y)
    return P[a].y<P[b].y;
  else if (P[a].t != P[b].t)
    return P[a].t>P[b].t;
  else
    return P[a].r<P[b].r;
};

bool CompareY(const int& a, const int& b)
{  
  if(P[a].r==P[b].r && P[a].t==P[b].t)
    return 0;
  else if (P[a].y != P[b].y)
    return P[a].y < P[b].y;
  else if(P[a].t==eLL && (P[b].t==eLL || P[b].t==eRL) && P[a].x != P[b].x)
    return P[a].x < P[b].x;
  else if(P[a].t==eLL && P[b].t==eLL)
    return P[a].r < P[b].r;
  else if(P[a].t==eLL && P[b].t==eRL)
    return 0;
  else if(P[a].t==eLL && (P[b].t==eRU || P[b].t==eLU))
    return 0;
  else if(P[a].t==eLU && (P[b].t==eLL || P[b].t==eRL))
    return 1;
  else if(P[a].t==eLU && (P[b].t==eLU || P[b].t==eRU))
    return 1;
  else if((P[a].t==eRL || P[a].t==eRU) && (P[b].t==eLL || P[b].t==eRL))
    return 1;
  else if((P[a].t==eRL || P[a].t==eRU) && (P[b].t==eLU || P[b].t==eRU))
    return 0;
  
  return 1;
};

SetI all(CompareP);
SetI sY(CompareY);
SetI sR(CompareR);

int n, n4;

void join(int r1, int r2)
{
  int p1,p2;
  
  p1 = r1*4;
  p2 = r2*4;
 
  all.erase(p1);
  all.erase(p1+1);
  all.erase(p1+2);
  all.erase(p1+3);
  all.erase(p2);
  all.erase(p2+1);
  all.erase(p2+2);
  all.erase(p2+3);

  R[r1].x1 = min(R[r1].x1, R[r2].x1);
  R[r1].x2 = max(R[r1].x2, R[r2].x2);
  R[r1].y1 = min(R[r1].y1, R[r2].y1);
  R[r1].y2 = max(R[r1].y2, R[r2].y2);
  
  R[r2].d = 0;
  
  P[p1].x = R[r1].x1;
  P[p1].y = R[r1].y1;
  P[p1+1].x = R[r1].x1;
  P[p1+1].y = R[r1].y2;
  P[p1+2].x = R[r1].x2;
  P[p1+2].y = R[r1].y1;
  P[p1+3].x = R[r1].x2;
  P[p1+3].y = R[r1].y2;
  
  P[p2].d =P[p2+1].d = P[p2+2].d = P[p2+3].d = 0;

  all.insert(p1);
  all.insert(p1+1);
  all.insert(p1+2);
  all.insert(p1+3);
}

void doAll()
{
  SetIit it = all.begin();
  SetIit itf;
  int p, p2;
  while(it!=all.end())
  {
    p = *it;
    
    if(sY.empty())
    {
      sY.insert(p);
      ++it;
      continue;
    }
    if((itf = sY.lower_bound(p)) == sY.begin())
    {
      sY.insert(p);
      ++it;
      continue;
    }
    --itf;
    p2 = *itf;
    switch(P[p].t)
    {
      case eLL:
        if(P[p2].t==eLL)
        {
          join(P[p].r, P[p2].r);
          sY.clear();
          it=all.begin();
          continue;
        }
        else
         sY.insert(p);
        break;
      case eLU:
        if(P[p2].t==eLL && P[p].r == P[p2].r)
        {
          sY.insert(p);
        }
        else
        {
          join(P[p].r, P[p2].r);
          sY.clear();
          it=all.begin();
          continue;
        }
        break;
      case eRL:
        if(P[p2].t==eLL && P[p].r != P[p2].r)
        {
          join(P[p].r, P[p2].r);
          sY.clear();
          it=all.begin();
          continue;
        }
        break;
      case eRU:
        if(P[p2].t==eLL && P[p].r != P[p2].r)
        {
          join(P[p].r, P[p2].r);
          sY.clear();
          it=all.begin();
          continue;
        }
        else
        {
          sY.erase(4*(p/4));
          sY.erase(4*(p/4)+1);
        }
        break;
    }
    ++it;
  }
}

int main()
{
  ios_base::sync_with_stdio(0);
  
  int x1, y1, x2, y2;
  
  cin >> n;
  n4 = n*4;
  for(int i=0; i<n; ++i)
  {
    cin >> x1 >> x2 >> y1 >> y2;
    
    R[i].x1 = x1;
    R[i].x2 = x2;
    R[i].y1 = y1;
    R[i].y2 = y2;
    R[i].d = 1;
    
    P[4*i].x = x1;
    P[4*i].y = y1;
    P[4*i].t = eLL;
    
    P[4*i+1].x = x1;
    P[4*i+1].y = y2;
    P[4*i+1].t = eLU;
    
    P[4*i+2].x = x2;
    P[4*i+2].y = y1;
    P[4*i+2].t = eRL;
    
    P[4*i+3].x = x2;
    P[4*i+3].y = y2;
    P[4*i+3].t = eRU;
    
    P[4*i].r = P[4*i+1].r = P[4*i+2].r = P[4*i+3].r = i;
    
    all.insert(4*i);
    all.insert(4*i+1);
    all.insert(4*i+2);
    all.insert(4*i+3);
  }
  
  doAll();
 
  for(int i=0; i<n; ++i)
  {
    if(R[i].d)
      sR.insert(i);
  }
 
 cout << sR.size()<<endl;
 for(SetIit it = sR.begin(); it!=sR.end(); ++it)
 {
   cout << R[*it].x1<<" "<< R[*it].x2<<" "<< R[*it].y1<<" "<< R[*it].y2<<endl;
 }
 return 0;
}