F

#include <bits/stdc++.h>

using namespace std;

struct Event
{
    int x ,y1 ,y2 ,type;
    Event(): x(0) ,y1(0) ,y2(0) ,type(0) {}
    Event(int _x ,int _y1 ,int _y2 ,int _type): x(_x) ,y1(_y1) ,y2(_y2) ,type(_type) {}
};

struct Rectangle
{
    int x1 ,y1 ,x2 ,y2;
    Rectangle(): x1(0) ,y1(0) ,x2(0) ,y2(0) {}
    Rectangle(int _x1 ,int _y1 ,int _x2 ,int _y2): x1(_x1) ,y1(_y1) ,x2(_x2) ,y2(_y2) {}
};

class SegTree
{
    private:
        #define lf (p << 1)
        #define rg (lf | 1)

        vector< long long > lazy;
        vector< long long > st;
        int n;

        long long conquer(long long stL ,long long stR)
        {
            return stL + stR;
        }

        void UPD(int i ,int j ,long long v ,int p ,int L ,int R)
        {
            if( R < i || j < L ) return;

            if( i <= L && R <= j )
            {
                lazy[p] += v;
                if( lazy[p] > 0 ){
                    st[p] = R - L + 1;
                } else if( L == R ){
                    st[p] = 0;
                } else {
                    st[p] = conquer(st[lf] ,st[rg]);
                }
                return;
            }

            int M = (L + R) >> 1;
            UPD(i ,j ,v ,lf ,L ,M);
            UPD(i ,j ,v ,rg ,M + 1 ,R);

            if( lazy[p] == 0 ){
                st[p] = conquer(st[lf] ,st[rg]);
            }
        }

    public:
        SegTree(int sz)
        {
            n = sz;
            st.assign(4 * n ,0);
            lazy.assign(4 * n ,0);
        }

        void UPD(int L ,int R ,long long v)
        {
            UPD(L ,R ,v ,1 ,0 ,n - 1);
        }

        long long QRY()
        {
            return st[1];
        }
};

long long areaOfRectangleUnion(int &n ,vector< Rectangle > &rects)
{
    // the y2 in rect[i] should be decreased by 1 to calculate [y1 y2] inclusive on the yAxis.

    int stSize = 0;
    vector< Event > E;
    for(int i = 0 ; i < n ; i++)
    {
        E.emplace_back(rects[i].x1 ,rects[i].y1 ,max(rects[i].y1 ,rects[i].y2 - 1) ,+1);
        E.emplace_back(rects[i].x2 ,rects[i].y1 ,max(rects[i].y1 ,rects[i].y2 - 1) ,-1);
        stSize = max(stSize ,rects[i].y2);
    }

    sort(E.begin(), E.end() ,[&](Event e1 ,Event e2){
        if( e1.x < e2.x ) return true;
        if( e1.x > e2.x ) return false;
        return e1.type > e2.type;
    });

    SegTree st(stSize);
    long long area = 0 ,last = INT_MIN;

    for(Event e : E)
    {
        area += st.QRY() * (long long)(e.x - last);
        st.UPD(e.y1 ,e.y2 ,e.type);
        last = e.x;
    }

    return area;
}

Rectangle lineToRect(Rectangle line ,int r ,Rectangle border)
{
    return Rectangle (
        max(line.x1 - r ,border.x1),
        max(line.y1 - r ,border.y1),
        min(line.x2 + r ,border.x2),
        min(line.y2 + r ,border.y2)
    );
}

bool f(int r ,long long lowerBoundArea ,int n ,vector< Rectangle > &lines ,Rectangle border)
{
    vector< Rectangle > rects;
    for(Rectangle line : lines){
        rects.emplace_back(lineToRect(line ,r ,border));
    }

    return lowerBoundArea <= areaOfRectangleUnion(n ,rects);
}

int main()
{
    int n;
    scanf("%d" ,&n);

    vector< Rectangle > lines;
    for(int i = 0 ; i < n ; i++)
    {
        int x1 ,y1; scanf("%d%d" ,&x1 ,&y1);
        int x2 ,y2; scanf("%d%d" ,&x2 ,&y2);

        if( x1 > x2 ) swap(x1 ,x2);
        if( y1 > y2 ) swap(y1 ,y2);

        lines.emplace_back(x1 ,y1 ,x2 ,y2);
    }

    int p;
    scanf("%d" ,&p);

    Rectangle border;
    scanf("%d%d" ,&border.x1 ,&border.y1);
    scanf("%d%d" ,&border.x2 ,&border.y2);

    long long totalArea = (border.x2 - border.x1) * 1ll * (border.y2 - border.y1);
    long long lowerBoundArea = (99ll + totalArea * p) / 100ll;

    int L = 1 ,R = 100100;
    for(int i = 0 ; i < 30 ; i++)
    {
        int M = (L + R) >> 1;
        f(M ,lowerBoundArea ,n ,lines ,border) ? R = M : L = M;
    }

    printf("%d\n" ,R);
    return 0;
}