#define READ_NUM_TEST_CASES  false
#define USE_FAST_IO          true

////////////////////////////////////////////////////////////////////////////////
// AMALGAMATE: "include/template.hpp" BEGINS HERE
//
	
	
	#include <bits/stdc++.h>
	using namespace std;
	
	
	////////////////////////////////////////////////////////////////////////////////
	// AMALGAMATE: "include/abbrevs.hpp" BEGINS HERE
	//
		
		#define UI unsigned int
		
		#define LL long long
		#define ULL unsigned long long
		
		#define PII pair<int,int>
		
		
		#define RI ri()
		#define RUI rui()
		
		#define RLL rll()
		#define RULL rull()
		
		#define RSTR rstr()
		
		
		
		#define FO(i,a,b) for(int i=(a); i<int(b); ++i)
		#define OF(i,a,b) for(int i=(b)-1; i>=int(a); --i)
		
		#define FOR(i,n) FO(i,0,n)
		#define ROF(i,n) OF(i,0,n)
		
		
		#define MIN(a,b) ((a)<(b) ? (a) : (b))
		#define MAX(a,b) ((b)<(a) ? (a) : (b))
		
		#define REMIN(a,b) ((a) = min(a,b))
		#define REMAX(a,b) ((a) = max(a,b))
		
		#define ALL(c) (c).begin(),(c).end()
		
		#define SQR(x) ((x)*(x))
		
		
		
		bool is_pow(int x) {
			return (x&(x-1)) == 0;
		}
		
	
	//
	// AMALGAMATE: "include/abbrevs.hpp" ENDS HERE
	////////////////////////////////////////////////////////////////////////////////
	
	
	#if USE_FAST_IO
		
		////////////////////////////////////////////////////////////////////////////////
		// AMALGAMATE: "include/fast-io.hpp" BEGINS HERE
		//
			
			
			//#define FREAD  fread
			//#define FWRITE fwrite
			
			#define FREAD  fread_unlocked
			#define FWRITE fwrite_unlocked
			
			
			
			
			
			
			struct Buffer {
				FILE* const stream;
				const int buffer_size;
			
				uint8_t* const buff;
				int pos = 0;
			
				Buffer(FILE* a_stream, int a_buffer_size) :
						stream( a_stream ),
						buffer_size( a_buffer_size ),
						buff( new uint8_t[ buffer_size ] ) {
					setvbuf(stream, NULL, _IONBF, 0);
				}
			
				~Buffer() {
					delete[] buff;
				}
			};
			
			
			
			
			
			
			
			
			
			
			class In_Buffer : private Buffer {
			public:
				In_Buffer(FILE* a_stream, int a_buffer_size) : Buffer(a_stream, a_buffer_size) {
					FREAD(buff, 1, buffer_size, stream);
				}
			
			public:
				void prepare(int num_chars) {
					auto remaining = buffer_size - pos;
					if(remaining >= num_chars) return;
			
					assert(remaining >= 0); // prevent compiler warning
					memcpy(buff, buff+pos, remaining);
			
					int read = FREAD(buff+remaining, 1, pos, stream);
					int block_end = remaining + read;
					memset(buff + block_end, 0, buffer_size - block_end);
					pos = 0;
				}
			
			public:
				char get_unchecked() {
					return buff[ pos++ ];
				}
			};
			
			
			template<class INT>
			INT read_unsigned(In_Buffer& buff) {
				buff.prepare(25);
			
				char c = buff.get_unchecked();
				while(c < '-') c = buff.get_unchecked();
			
				INT r = 0;
			
				for(;;) {
					if(c < '0') return r;
					c -= '0';
					r = r*10 + c;
					c = buff.get_unchecked();
				}
			}
			
			
			template<class INT>
			INT read_signed(In_Buffer& buff) {
				buff.prepare(25);
			
				char c = buff.get_unchecked();
				while(c < '-') c = buff.get_unchecked();
			
				bool minus = false;
				if(c=='-') {
					c = buff.get_unchecked();
					minus = true;
				}
			
				INT r = 0;
			
				for(;;)
				{
					if(c < '0') return minus ? -r : r;
					r = r*10 + (c-'0');
					c = buff.get_unchecked();
				}
			}
			
			
			
			
			In_Buffer& operator>>( In_Buffer& buff, char& c) {
				buff.prepare(1);
				c = buff.get_unchecked();
				return buff;
			}
			
			
			
			In_Buffer& operator>>( In_Buffer& buff, UI& r) { r = read_unsigned<UI>(buff); return buff; }
			In_Buffer& operator>>( In_Buffer& buff, ULL& r) { r = read_unsigned<ULL>(buff); return buff; }
			
			In_Buffer& operator>>( In_Buffer& buff, int& r) { r = read_signed<int>(buff); return buff; }
			In_Buffer& operator>>( In_Buffer& buff, LL& r) { r = read_signed<LL>(buff); return buff; }
			
			In_Buffer& operator>>( In_Buffer& buff, string& r) {
				r.clear();
			
				char c = buff.get_unchecked();
				while(c <= ' ') c = buff.get_unchecked();
			
				do {
					r.push_back( c );
					c = buff.get_unchecked();
				} while(c > ' ');
			
				return buff;
			}
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			class Out_Buffer : private Buffer {
			public:
				Out_Buffer(FILE* a_stream, int a_buffer_size) : Buffer(a_stream, a_buffer_size) {}
			
				~Out_Buffer() {
					flush();
				}
			
			public:
				void prepare(int num_chars) {
					if(buffer_size - pos >= num_chars) return;
					flush();
				}
			
				void flush() {
					FWRITE(buff, 1, pos, stream);
					pos = 0;
				}
			
			public:
				void put_unchecked(const char& c) {
					buff[ pos++ ] = c;
				}
			
				void put_unchecked(const char* str, int len) {
					memcpy(buff+pos, str, len);
					pos += len;
				}
			};
			
			
			
			
			
			
			template<class INT>
			void write_signed(Out_Buffer& buff, const INT& i) {
				buff.prepare(25);
			
				if(i == 0) {
					buff.put_unchecked('0');
					return;
				}
			
				auto ci = i;
			
				if(ci < 0) {
					buff.put_unchecked('-');
					ci = -ci;
				}
			
				const int sz = 25;
				char temp[sz];
				int pos = sz;
			
				while(ci) {
					temp[ --pos ] = '0' + ci%10;
					ci/=10;
				}
			
				buff.put_unchecked(temp+pos, sz-pos);
			}
			
			
			
			template<class INT>
			void write_unsigned(Out_Buffer& buff, const INT& i) {
				buff.prepare(25);
			
				if(i==0) {
					buff.put_unchecked('0');
					return;
				}
			
				const int sz = 25;
				char temp[sz];
				int pos = sz;
			
				auto ci = i;
			
				while(ci) {
					temp[ --pos ] = '0' + ci%10;
					ci/=10;
				}
			
				buff.put_unchecked(temp+pos, sz-pos);
			}
			
			
			
			Out_Buffer& operator<<( Out_Buffer& buff, const char& c) {
				buff.prepare(1);
				buff.put_unchecked( c );
				return buff;
			}
			
			Out_Buffer& operator<<( Out_Buffer& buff, const UI& r) { write_unsigned<UI>(buff, r); return buff; }
			Out_Buffer& operator<<( Out_Buffer& buff, const ULL& r) { write_unsigned<ULL>(buff, r); return buff; }
			
			Out_Buffer& operator<<( Out_Buffer& buff, const int& r) { write_signed<int>(buff, r); return buff; }
			Out_Buffer& operator<<( Out_Buffer& buff, const LL& r) { write_signed<LL>(buff, r); return buff; }
			
			Out_Buffer& operator<<( Out_Buffer& buff, const char* cstr) { auto len = strlen(cstr); buff.prepare(len); buff.put_unchecked(cstr, len); return buff; }
			Out_Buffer& operator<<( Out_Buffer& buff, const string& str) { buff.prepare( str.size() ); buff.put_unchecked(str.data(), str.size()); return buff; }
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			#define BUFF_SIZE 32768
			In_Buffer  fast_cin(  stdin,  BUFF_SIZE );
			Out_Buffer fast_cout( stdout, BUFF_SIZE );
			//Out_Buffer fast_cerr( stderr, BUFF_SIZE );
			
			char fast_endl = '\n';
			
		
		//
		// AMALGAMATE: "include/fast-io.hpp" ENDS HERE
		////////////////////////////////////////////////////////////////////////////////
		
		#define cin fast_cin
		#define cout fast_cout
		#define endl fast_endl
	#else
		
		////////////////////////////////////////////////////////////////////////////////
		// AMALGAMATE: "include/slow-io.hpp" BEGINS HERE
		//
			
			struct Slow_IO_Singleton {
				Slow_IO_Singleton() {
					ios_base::sync_with_stdio( false );
			
					std::cin.tie( nullptr );
					std::cout.tie( nullptr );
			
					setlocale(LC_ALL,"C");
			
					const int buffer_size = 32768;
			
					static char stdin_buffer[ buffer_size ];
					static char stdout_buffer[ buffer_size ];
			
					cin.rdbuf()->pubsetbuf( stdin_buffer, buffer_size );
					cout.rdbuf()->pubsetbuf( stdout_buffer, buffer_size );
				}
			
				~Slow_IO_Singleton() {
			
				}
			};
			
			
			Slow_IO_Singleton slow_io_singleton;
			
		
		//
		// AMALGAMATE: "include/slow-io.hpp" ENDS HERE
		////////////////////////////////////////////////////////////////////////////////
		
		#ifndef DEBUG
			#define endl '\n'
		#endif
	#endif
	
	
	////////////////////////////////////////////////////////////////////////////////
	// AMALGAMATE: "include/abbrevs-io.hpp" BEGINS HERE
	//
		
		
		
		
		int ri()   { int r; cin >> r; return r; }
		UI  rui()  { UI r; cin >> r; return r; }
		
		LL  rll()  { LL r;  cin >> r; return r; }
		ULL rull() { ULL r; cin >> r; return r; }
		
		string rstr() {string s; cin >> s; return s; }
		
	
	//
	// AMALGAMATE: "include/abbrevs-io.hpp" ENDS HERE
	////////////////////////////////////////////////////////////////////////////////
	
	
	
	////////////////////////////////////////////////////////////////////////////////
	// AMALGAMATE: "include/debug.hpp" BEGINS HERE
	//
		
		
		#define ASS(x) assert(x)
	
	//
	// AMALGAMATE: "include/debug.hpp" ENDS HERE
	////////////////////////////////////////////////////////////////////////////////
	
	
	
	
	//
	// for salgo
	#define CONTEST_MODE
	
	namespace salgo {};
	using namespace salgo;
	//

//
// AMALGAMATE: "include/template.hpp" ENDS HERE
////////////////////////////////////////////////////////////////////////////////


// #define dbg 0

//
// snippets/fenwick.hpp
//
template<class T>
class Fenwick {
	vector<T> _v;
	static auto _ls_one(int s) { return s & (-s); }

public:
	Fenwick(int n) : _v(n+1) {}

	// sum range [0..b)
	T sum(int b) {
		T r = 0;
		for (; b; b -= _ls_one(b)) r += _v[b];
		return r;
	}

	// sum range [a..b)
	T sum(int a, int b) { if(a >= b) return 0; return sum(b) - sum(a); } //todo: decide what happens when a>=b

	// fw[k] += v
	void update(int k, int mod) {
		k += 1;
		for (; k <= (int)_v.size()-1; k += _ls_one(k)) _v[k] += mod;
	}
};



class UF {
	struct Node {
		int parent;

		//
		// per-set data - EDIT HERE
		//int size = 1;
		void on_merge_from(const Node& /* o */) { // called by UF implementation
			//size += o.size;
		}
		//


		//
		// path aggreg - EDIT HERE
		//
		// If at any point you're calling merge(some_non_root, b),
		// path aggregation isn't real path aggregation,
		// but instead can aggregate paths that go back and forth,
		// visiting some vertices several times.
		// This works for e.g. XOR-ing edge weights,
		// or any other involution (OP == OP^-1)
		//
		// It's meant for edge aggregation. For vertices,
		// the code would require some changes.
		//
		// When calling merge(a,b), that is creating a new edge,
		// be sure to aggregate this edge *after* merging, like this:
		//   uf.merge(a,b);
		//   uf[a].path_edges_parity = 1;
		//
		//bool path_edges_parity = 0;
		void on_path_aggreg(const Node& /* o */) { // called by UF implementation
			//path_edges_parity ^= o.path_edges_parity;
		}
		//

	};
	vector<Node> v;

public:
	UF(int sz) : v(sz) {
		FOR(i,sz) v[i].parent = i;
	}

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

		int parent = v[x].parent;
		int root = find( parent );
		v[x].on_path_aggreg( v[parent] );
		v[x].parent = root;

		return root;
	}


	void merge(int a, int b) {
		int fa = find(a);
		int fb = find(b);
		if(fa == fb) return;

		v[fa].parent = a;
		v[fa].on_path_aggreg( v[a] );

		v[a].parent = b;

		v[fb].on_merge_from( v[fa] );
	}

	// helpers
	bool same(int a, int b) { return find(a) == find(b); }
	Node& find_node(int x) { return v[ find(x) ]; }
	auto& operator[](int a) { return v[ a ]; }
};






struct Test_Case {

	struct X {
		int x;

		vector<int> ids;

		bool operator<(const X& o) const { return x < o.x; }
	};

	using Pts = vector<X>;

	int solve_dim(Pts& pts, int domain) {
		sort(ALL(pts));

		const int total_pts = pts.size();

		// merge points with the same `x`
		{
			Pts new_pts;
			for(auto& pt : pts) {
				if(new_pts.empty() || new_pts.back().x != pt.x) {
					new_pts.push_back(pt);
				}
				else {
					new_pts.back().ids.push_back( pt.ids[0] );
				}
			}
			pts = std::move(new_pts);
		}

		const int n = pts.size();

		FOR(clone, 1) FOR(i,n) {
			auto new_pt = pts[i];
			new_pt.x += domain * (clone+1);
			pts.push_back(new_pt);
		}

		auto where_last = vector<int>(total_pts + 5);
		for(auto& e : where_last) e = -1;

		auto num_at = Fenwick<int>(pts.size() + 5);

		auto uf = UF(n+5);

		FOR(i, pts.size()) {
			// if(dbg) cout << endl << "process x == " << pts[i].x << " at index " << i << endl;

			for(auto& id : pts[i].ids) {
				// if(dbg) cout << "process id " << id << endl;

				if(where_last[id] != -1) {
					int fr = where_last[id]+1;
					int to = i;

					// if(dbg) cout << "points inbetween: " << num_at.sum( fr, to ) << "   range [" << fr << ", " << to << ")" << endl;

					if(num_at.sum(fr, to) == 0) {
						int a = where_last[id];
						int b = i-1;

						a %= n;
						b %= n;

						// if(dbg) cout << "merge: " << a << " " << b << endl;
						uf.merge(a, b);
					}
				}
			}

			for(auto& id : pts[i].ids) {
				if(where_last[id] != -1) {
					// if(dbg) cout << "update " << where_last[id] << " -2" << endl;
					num_at.update( where_last[id], -2 );
				}
				// if(dbg) cout << "update " << i << " +1" << endl;
				num_at.update(i, 1);

				where_last[id] = i;
			}
		}

		vector<int> results(n + 5);

		auto get_len = [&](int i) {
			auto next = (i+1) % n;

			auto len = pts[next].x - pts[i].x;
			len = (domain + len) % domain;

			return len;
		};

		FOR(i,n) {
			auto len = get_len(i);

			// if(dbg) cout << "uf find " << i << endl;
			// if(dbg) cout << i << " -> " << uf.find(i) << " add len " << len << endl;

			results[ uf.find(i) ] += len;
		}

		int mx = 0;
		for(auto& r : results) REMAX(mx, r);

		// if(dbg) cout << "result " << mx << endl;

		return mx;
	}

	void solve() {
		int n = RI;

		int size[2];
		size[0] = RI;
		size[1] = RI;

		Pts pts[2];

		FOR(i,n) {
			auto x1 = RI;
			auto y1 = RI;

			auto x2 = RI;
			auto y2 = RI;
			
			pts[0].push_back({x1, {i}});
			pts[0].push_back({x2, {i}});

			pts[1].push_back({y1, {i}});
			pts[1].push_back({y2, {i}});
		}

		int r[2];

		FOR(dim, 2) {
			// if(dbg) cout << endl << "DIM " << dim << endl;
			r[dim] = solve_dim(pts[dim], size[dim]);
		}

		cout << 1LL * r[0] * r[1] << endl;
	}

	int icase = -1;
}; // struct Test_Case







int main() {
	int num_cases = READ_NUM_TEST_CASES ? RI : 1;
	
	FOR(i, num_cases) {
		Test_Case tc;
		tc.icase = i;
		tc.solve();
	}

	return 0;
}