#include <bits/stdc++.h>
using namespace std;
#define asp ""
#define aps ''
#define one 1
#define two 2
#define dif !=
using namespace std;
const int maxn = 1e5 + 5;
typedef long long ll;
struct Node{

	int cover = 0;
	int score = 0;
};

struct line{

	ll xa,ya;
	ll xb,yb;
};

struct event{

	ll x;
	int ya,yb;
	bool inp;
};

vector<Node> tree(4*maxn);

// build o*(n*log n)
void build(int pos,int i,int j){

	int esq = two*pos;
	int dir = two*pos + one;
	int mid = (i+j)/two;

	tree[pos].cover = 0;
	tree[pos].score = 0;

	if(i == j) return ;
	build(esq,i,mid);
	build(dir,mid+one,j);
}

int update(int pos,int i,int j,int l,int r,int op){

	int esq = two*pos;
	int dir = two*pos + one;
	int mid = (i+j)/two;
	int score = 0;

	if(i > r || j < l) return tree[pos].score;
	else if(i >= l && j <= r){

		tree[pos].cover += op;
		if(tree[pos].cover == 0 && i dif j){
			tree[pos].score = tree[esq].score + tree[dir].score;
		}
		else if(tree[pos].cover == 0){
			tree[pos].score = 0;
		}
		else tree[pos].score = (j-i +one);
	}
	else{
		tree[pos].score = update(esq,i,mid,l,r,op);
		tree[pos].score += update(dir,mid+one,j,l,r,op);

		if(tree[pos].cover > 0) tree[pos].score = (j-i + one);
	}

	return tree[pos].score;
}

vector<line> g;
vector<event> lista;
ll minx,miny,maxx,maxy;

bool comp(event a,event b){

	return (a.x < b.x);
}

void preProcess(int p){
	lista.clear();
	event aux;

	for(int i=0;i<g.size();i++){
		if(g[i].xa == g[i].xb){
			// open event
			aux.x = max(minx,g[i].xa-p);
			aux.ya = max(g[i].ya-p,miny);
			aux.yb = min(g[i].yb+p,maxy);
			aux.inp = true;
			lista.push_back(aux);
			// close event
			aux.x = min(maxx,g[i].xa+p);
			aux.ya = max(g[i].ya-p,miny);
			aux.yb = min(g[i].yb+p,maxy);
			aux.inp = false;
			lista.push_back(aux);
		}
		else{
			// open event
			aux.x = max(g[i].xa-p,minx);
			aux.ya = max(miny,g[i].ya-p);
			aux.yb = min(maxy,g[i].yb+p);
			aux.inp = true;
			lista.push_back(aux);
			// close event
			aux.x = min(g[i].xb+p,maxx);
			aux.ya = max(miny,g[i].ya-p);
			aux.yb = min(maxy,g[i].yb+p);
			aux.inp = false;
			lista.push_back(aux);
		}
	}

	sort(lista.begin(),lista.end(),comp);
}

ll unionrect(int p){

	preProcess(p);
	build(one,0,1e5);

	ll last = minx;
	ll len = 0;
	ll ans = 0;

	for(int i=0;i<lista.size();i++){
		ans += len * (lista[i].x - last);
		last = lista[i].x;
		if(lista[i].inp){
			len = update(one,0,1e5,lista[i].ya,lista[i].yb,one);
		}
		else{
			len = update(one,0,1e5,lista[i].ya,lista[i].yb,-one);
		}
	}

	return ans;
}

int solve(int n,ll area){

	int s = 0;
	int e = 1e5;
	int p = (s+e)/two;
	ll at;

	while(s < e){

		at = unionrect(p);
		if(at >= area){
			e = p;
			p = (s+e)/two;
		}
		else{
			s = p+one;
			p = (s+e)/two;
		}
	}

	return s;
}

int main(){

	ios::sync_with_stdio(0);
	cin.tie(0);

	int n;

	cin >> n;

	line aux;

	for(int i=0;i<n;i++){
		cin >> aux.xa >> aux.ya >> aux.xb >> aux.yb;
		g.push_back(aux);
	}

	int Perc;
	cin >> Perc;

	cin >> minx >> miny >> maxx >> maxy;
	ll area = (abs(minx - maxx)) * (abs(maxy - miny));
	area = (area * Perc + 99)/100;
	cout << solve(n,area) << endl;
}