#include <iostream>
#include <algorithm>
#include <cmath>
#include <queue>
#include <map>
#include <iomanip>

typedef long long ll;
typedef long double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 4e4 + 10, MAXM = 210;

int n, m, et, vt, ss, tt;

const lf eps = 1e-12, pi = acos(-1.0);
inline int sgn(lf x) { return x > eps ? 1 : (x < -eps ? -1 : 0); }
struct Point
{
    lf x, y;
    Point(lf _x = 0, lf _y = 0) : x(_x), y(_y) {}
    Point operator + (const Point &u) const { return Point(x + u.x, y + u.y); }
    Point operator - (const Point &u) const { return Point(x - u.x, y - u.y); }
    Point operator * (const lf u) const { return Point(x * u, y * u); }
    Point operator / (const lf u) const { return Point(x / u, y / u); }
    bool operator == (const Point &u) const { return sgn(x - u.x) == 0 && sgn(y - u.y) == 0; }
    bool operator < (const Point &u) const
    {
        if (sgn(x - u.x) == 0) return sgn(y - u.y) < 0;
        return sgn(x - u.x) < 0;
    }
    friend ostream& operator << (ostream& out, Point u)
    {
        out << u.x << ' ' << u.y;
        return out;
    }
};
inline lf dot(const Point &u, const Point &v) { return u.x * v.x + u.y * v.y; }
inline lf det(const Point &u, const Point &v) { return u.x * v.y - u.y * v.x; }
inline bool quadrant(const Point &u)
{
    if (sgn(u.y) == 0) return sgn(u.x) < 0;
    return sgn(u.y) < 0;
}
inline lf sqr(lf x) { return x * x; }
inline lf dist(const Point &u) { return sqrt(sqr(u.x) + sqr(u.y)); }
struct Line
{
    Point s, t;
};
inline bool Two_side(const Point &a, const Point &b, const Line &c)
{
    return sgn(det(a - c.s, c.t - c.s)) * sgn(det(b - c.s, c.t - c.s)) < 0;
}
inline bool Point_on_segment(const Point &a, const Line &l)
{
    return sgn(det(l.s - a, a - l.t)) == 0 && sgn(dot(l.s - a, a - l.t)) >= 0;
}
inline bool Inter_judge(const Line &a, const Line &b)
{
    if (Point_on_segment(a.s, b) || Point_on_segment(a.t, b) || Point_on_segment(b.s, a) || Point_on_segment(b.t, a)) return 1;
    return Two_side(a.s, a.t, b) && Two_side(b.s, b.t, a);
}
inline Point Line_intersect(const Line &u, const Line &v)
{
    if (Point_on_segment(u.s, v)) return u.s;
    if (Point_on_segment(u.t, v)) return u.t;
    if (Point_on_segment(v.s, u)) return v.s;
    if (Point_on_segment(v.t, u)) return v.t;
    lf x = det(u.t - u.s, v.s - u.s), y = -det(u.t - u.s, v.t - u.s);
    return (v.s * y + v.t * x) / (x + y);
}
inline lf angle(const Point &u, const Point &v)
{
    lf ang = atan2(u.x, u.y) - atan2(v.x, v.y);
    if (sgn(ang - pi) > 0) ang -= 2 * pi;
    else if (sgn(ang + pi) < 0) ang += 2 * pi;
    return ang; 
}

Point S, T;
Line a[MAXM];

typedef unsigned long long ull;
const ull B = 13331;
map <ull, bool> mp;
inline ull Trs(const Line &u) { ull a = (ull)u.s.x * B + (ull)u.s.y, b = (ull)u.t.x * B + (ull)u.t.y; if (a > b) swap(a, b); return a * B * B + b; }

Point nd[MAXN];
vector <Point> _it[MAXM];
vector <int> it[MAXM];
struct Node
{
    int v, id;
    Point pt;
    Node (int a, int b, Point c) : v(a), id(b), pt(c) {}
};
vector <Node> g[MAXN];
inline bool cmp(const Node &u, const Node &v)
{
    bool a = quadrant(u.pt), b = quadrant(v.pt);
    if (a ^ b) return a < b;
    int s = sgn(det(u.pt, v.pt));
    if (s == 0) return sgn(dist(u.pt) - dist(v.pt)) < 0;
    return s > 0;
}

Line sgt[MAXN << 2];
int val[MAXN << 2];
map <int, bool> vis[MAXN];
map <int, int> idx[MAXN];

int st[MAXN << 2], top;
int st2[MAXN << 2], top2;
inline void DFS(int u, int ed)
{
    st2[++top2] = u;
    if (g[u].size() == 1) return st[++top] = g[u][0].id, DFS(g[u][0].v, g[u][0].id), void();
    int cur = idx[u][ed];
    if (cur == g[u].size() - 1) cur = 0; else cur++;
    int b = g[u][cur].v, v = g[u][cur].id;
    if (!vis[ed][v]) vis[ed][v] = 1, st[++top] = v, DFS(b, v);
}

int mrk[MAXN];
vector <int> fed[MAXN << 1];
vector <pair <int, int>> e[MAXN << 1], tmp;

int dis[MAXN << 1]; bool avl[MAXN << 1];
vector <int> q0;
queue <int> q1;

int main()
{
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    Read(m), Read(S.x), Read(S.y), Read(T.x), Read(T.y);
    for (int i = 1; i <= m; i++)
    {
        Read(a[i].s.x), Read(a[i].s.y), Read(a[i].t.x), Read(a[i].t.y);
        mp[Trs(a[i])] = 1;
        // cout << "Segment((" << a[i].s.x << "," << a[i].s.y << "),(" << a[i].t.x << "," << a[i].t.y << "))\n";
    }
    // cout << '\n';
    int _m = m;
    for (int i = 1; i < m; i++)
    {
        if (a[i].s == a[i + 1].s) continue;
        Line cur = Line{a[i].s, a[i + 1].s};
        if (!mp[Trs(cur)]) a[++_m] = cur;
    }
    swap(m, _m);
    // for (int i = 1; i <= m; i++)
    // {
    //     cout << "Segment((" << a[i].s.x << "," << a[i].s.y << "),(" << a[i].t.x << "," << a[i].t.y << "))\n";
    // }

    for (int i = 1; i <= m; i++)
        for (int j = i + 1; j <= m; j++)
            if (Inter_judge(a[i], a[j]))
            {
                auto x = Line_intersect(a[i], a[j]);
                nd[++n] = x;
                _it[i].push_back(x), _it[j].push_back(x);
            }
    sort(nd + 1, nd + n + 1);
    // cout << fixed << setprecision(20);
    // for (int i = 1; i <= n; i++) cout << nd[i] << '\n'; cout << '\n';
    n = unique(nd + 1, nd + n + 1) - nd - 1;


    // cout << Inter_judge(a[1], a[4]) << '\n';
    // cout << a[1].s << ' ' << a[1].t << ' ' << a[4].s << ' ' << a[4].t << '\n';
    // cout << Point_on_segment(a[1].s, a[4]) << '\n';
    // cout << a[4].s - a[1].s << ' ' << a[1].s - a[4].t << '\n';
    // cout << sgn(det(a[4].s - a[1].s, a[1].s - a[4].t)) << ' ' << sgn(dot(a[4].s - a[1].s, a[1].s - a[4].t)) << '\n';
    // for (int i = 1; i <= n; i++) cout << nd[i] << '\n';
    // for (int i = 1; i <= m; i++)
    // {
    //     cout << "sgt " << i << ": ";
    //     for (auto x : _it[i]) cout << x << ' '; cout << '\n';
    // }

    for (int i = 1; i <= m; i++)
    {
        for (auto x : _it[i])
        {
            int cur = lower_bound(nd + 1, nd + n + 1, x) - nd;
            it[i].push_back(cur);
        }
        sort(it[i].begin(), it[i].end()), it[i].resize(unique(it[i].begin(), it[i].end()) - it[i].begin());
        // cout << "sgt " << i << ": ";
        // for (auto x : it[i]) cout << x << ' '; cout << '\n';
        // for (int j = 1; j < it[i].size(); j++) cout << it[i][j - 1] << ' ' << it[i][j] << '\n';
        for (int j = 1; j < it[i].size(); j++)
        {
            if (idx[it[i][j]][it[i][j - 1]]) { val[et] = max(val[et], (int)(i <= _m)); continue; }
            idx[it[i][j]][it[i][j - 1]] = idx[it[i][j - 1]][it[i][j]] = ++et;
            val[et] = (i <= _m), sgt[et] = Line{nd[it[i][j]], nd[it[i][j - 1]]};
            // cout << "Ed: " << it[i][j] << ' ' << it[i][j - 1] << ' ' << val[et] << '\n';
            g[it[i][j - 1]].emplace_back(it[i][j], et, nd[it[i][j]] - nd[it[i][j - 1]]);
            g[it[i][j]].emplace_back(it[i][j - 1], et, nd[it[i][j - 1]] - nd[it[i][j]]);
        }
    }
    for (int i = 1; i <= n; i++) idx[i].clear();
    // for (int i = 1; i <= et; i++)
    //     cout << sgt[i].s << ' ' << sgt[i].t << ' ' << val[i] << "\n";
    for (int i = 1; i <= n; i++)
    {
        sort(g[i].begin(), g[i].end(), cmp);
        for (int j = 0; j < g[i].size(); j++)
            idx[i][g[i][j].id] = j;
        // cout << "pt " << i << '\n';
        // for (auto x : g[i])
        //     cout << x.v << ' '; cout << '\n';
    }
    
    vt++;
    for (int i = 1; i <= n; i++)
    {
        if (g[i].size() <= 1) continue;
        for (int j = 0; j < g[i].size(); j++)
        {
            int u = g[i][j].id, v = g[i][(j + 1 == g[i].size() ? 0 : j + 1)].id;
            int a = g[i][j].v, b = g[i][(j + 1 == g[i].size() ? 0 : j + 1)].v;
            if (!vis[u][v])
            {
                st[top = 1] = v, top2 = 0, vis[u][v] = 1, DFS(b, v);
                lf suf = 0;
                for (int k = 1; k <= top2; k++)
                    suf += det(nd[st2[k]], nd[st2[k == top2 ? 1 : k + 1]]);
                if (sgn(suf) > 0)
                {
                    for (int k = 1; k <= top; k++)
                        if (mrk[st[k]]) e[1].emplace_back(mrk[st[k]], val[st[k]]), e[mrk[st[k]]].emplace_back(1, val[st[k]]);
                        else mrk[st[k]] = 1;
                }
                else
                {
                    vt++;
                    while (top2) fed[vt].push_back(st2[top2--]);
                    for (int k = 1; k <= top; k++)
                        if (mrk[st[k]]) e[vt].emplace_back(mrk[st[k]], val[st[k]]), e[mrk[st[k]]].emplace_back(vt, val[st[k]]);
                        else mrk[st[k]] = vt;
                }
            }
        }
    }
    // cout << vt << "\n";
    // for (int i = 1; i <= vt; i++)
    // {
    //     cout << "face " << i << ":\n";
    //     for (auto x : fed[i]) cout << x << ' '; cout << '\n';
    // }
    for (int i = 1; i <= vt; i++)
    {
        sort(e[i].begin(), e[i].end());
        tmp.clear();
        for (auto [v, w] : e[i])
            if (!tmp.size() || (tmp.back().first != v)) tmp.emplace_back(v, w);
        e[i] = tmp;
    }
    // for (int i = 1; i <= vt; i++)
    // {
    //     cout << i << ": ";
    //     for (auto [v, w] : e[i]) cout << v << " " << w << ' '; cout << '\n';
    // }
    ss = tt = 1;
    for (int i = 2; i <= vt; i++)
    {
        lf sum = 0;
        for (int j = 0; j < fed[i].size(); j++)
            sum += angle(nd[fed[i][j]] - S, nd[fed[i][(j + 1 == fed[i].size() ? 0 : j + 1)]] - S);
        if (sgn(sum) != 0) { ss = i; break; }
    }
    for (int i = 2; i <= vt; i++)
    {
        lf sum = 0;
        for (int j = 0; j < fed[i].size(); j++)
            sum += angle(nd[fed[i][j]] - T, nd[fed[i][(j + 1 == fed[i].size() ? 0 : j + 1)]] - T);
        if (sgn(sum) != 0) { tt = i; break; }
    }

    // cout << ss << ' ' << tt << "\n";

    for (int i = 1; i <= vt; i++) dis[i] = 2e9;
    dis[ss] = 0, q0.push_back(ss);
    while (!q0.empty() || !q1.empty())
    {
        int u;
        if (!q0.empty()) u = q0.back(), q0.pop_back();
        else u = q1.front(), q1.pop();
        if (avl[u]) continue;
        avl[u] = 1;
        for (auto [v, w] : e[u])
            if (dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if (w == 0) q0.push_back(v);
                else q1.push(v);
            }
    }
    cout << dis[tt] << '\n';
    // for (int i = 1; i <= vt; i++) cout << dis[i] << ' '; cout << '\n';
    return 0;
}