#include <bits/stdc++.h>
using namespace std;

template<class T>
bool chmax(T& a, const T& b) {
    if (a < b) { a = b; return true; }
    return false;
}
template<class T>
bool chmin(T& a, const T& b) {
    if (b < a) { a = b; return true; }
    return false;
}

// std::vector Declaration
template<typename T>
vector<T> make_v(size_t a) { return vector<T>(a); }
template<typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

// std::vector Declaration and Initialization
template<typename T>
vector<T> make_vector(size_t a, T x) { return vector<T>(a, x); }
template<typename T, typename U, typename... Ts>
auto make_vector(size_t a, U b, Ts... ts) {
    return vector<decltype(make_vector<T>(b,ts...))>(a, make_vector<T>(b, ts...));
}

// std::vector Input
template<typename T>
istream& operator>>(istream& is, vector<T>& v) {
    for (auto &e : v) is >> e;
    return is;
}

// std::vector Debug
template<typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "[";
    bool a = 1;
    for (auto e : v) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "]";
    return os;
}

// std::array Debug
template<typename T, size_t n>
ostream& operator<<(ostream& os, const array<T, n>& v) {
    os << "[";
    bool a = 1;
    for (auto e : v) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "]";
    return os;
}

// std::deque Debug
template<typename T>
ostream& operator<<(ostream& os, const deque<T>& d) {
    os << "[";
    bool a = 1;
    for (auto e : d) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "]";
    return os;
}

// std::pair Debug
template<typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    os << "(" << p.first << " " << p.second << ")";
    return os;
}

// std::set Debug
template<typename T>
ostream& operator<<(ostream& os, const set<T>& st) {
    os << "{";
    bool a = 1;
    for (auto e : st) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "}";
    return os;
}

// std::multiset Debug
template<typename T>
ostream& operator<<(ostream& os, const multiset<T>& st) {
    os << "{";
    bool a = 1;
    for (auto e : st) {
        os << (a ? "" : " ");
        os << e;
        a = 0;
    }
    os << "}";
    return os;
}

// std::map Debug
template<typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& mp) {
    os << "{";
    bool a = 1;
    for (auto e : mp) {
        os << (a ? "" : " ");
        os << e.first << ":" << e.second;
        a = 0;
    }
    os << "}";
    return os;
}

// std::tuple Debug
template<int N, class Tuple>
void out(ostream& os, const Tuple& t){}
template<int N, class Tuple, class H, class ...Ts>
void out(ostream& os, const Tuple& t) {
    if (N) os << " ";
    os << get<N>(t);
    out<N+1,Tuple,Ts...>(os, t);
}
template<class ...Ts>
ostream& operator<<(ostream& os, const tuple<Ts...>& t) {
    os << "(";
    out<0,tuple<Ts...>,Ts...>(os, t);
    os << ")";
    return os;
}

// Debug
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl

// Weighted edge
template<typename T>
struct edge {
    int src, to;
    T cost;

    edge() {}
    edge(int to, T cost) : src(-1), to(to), cost(cost) {}
    edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

    friend ostream& operator<<(ostream& os, const edge& e) {
        return os << "(" << e.src << "->" << e.to << ":" << e.cost << ")";
    }
};

using LL = int64_t;

#define fs first
#define sc second

const int64_t MOD = 1e9+7;

struct Point {
    double x;
    int y;
    friend ostream& operator<<(ostream& os, const Point& p) {
        return os << "(" << p.x << ":" << p.y << ")";
    }
};

double dist(Point& p1, Point& p2) {
    return sqrt((p1.x - p2.x) * (p1.x - p2.x) +
                (double)(p1.y - p2.y) * (p1.y - p2.y));
}


template<typename T>
vector<T> dijkstra(const vector<vector<edge<T>>> &g, int s) {
    const T INF = numeric_limits<T>::max();
    vector<T> d(g.size(), INF);

    using Pi = pair<T, int>;
    priority_queue<Pi, vector<Pi>, greater<Pi>> que;
    d[s] = 0;
    que.emplace(d[s], s);
    while (!que.empty()) {
        T cost;
        int v;
        tie(cost, v) = que.top();
        que.pop();
        if (d[v] < cost) continue;
        for (auto &e : g[v]) {
            T nxt = cost + e.cost;
            if (d[e.to] > nxt) {
                d[e.to] = nxt;
                que.emplace(nxt, e.to);
            }
        }
    }
    return d;
}

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);


    while (true) {
        int n; cin >> n;
        if (n == 0) break;

        vector<Point> p(n);
        set<int> ys;
        for (int i = 0; i < n; ++i) {
            double x;
            int y;
            cin >> x >> y;
            p[i] = { x, y };
            ys.insert(y);
        }

        for (int i = 0; i < n-1; ++i) {
            for (int y : ys) {
                int s = y - p[i].y, t = p[i+1].y - y;
                if (s * t > 0) {
                    p.push_back({ (s*p[i+1].x + t*p[i].x) / (s + t), y });
                }
            }
        }
        sort(p.begin(), p.end(), [](Point& p1, Point& p2){
                return p1.x < p2.x;
                });

        vector<pair<int,int>> pp;

        int start = -1;
        map<int,map<int,int>> mp;
        for (int i = 0; i < p.size(); ++i) {
            for (int j = i; j < p.size(); ++j) {
                if (p[i].y == p[j].y) {
                    if (i == 0 and j+1 == p.size()) {
                        start = pp.size();
                    }
                    mp[i][j] = pp.size();
                    pp.emplace_back(i, j);
                }
            }
        }

        vector<vector<edge<double>>> G(pp.size());

        for (int i = 0; i < pp.size(); ++i) {
            int i1 = pp[i].first, i2 = pp[i].second;
            for (int a = -1; a <= 1; ++a) {
                for (int b = -1; b <= 1; ++b) {
                    if (mp.count(i1+a) and mp[i1+a].count(i2+b)) {
                        int j = mp[i1+a][i2+b];
                        int j1 = pp[j].first, j2 = pp[j].second;
                        double d = dist(p[i1], p[j1]) + dist(p[i2], p[j2]);
                        G[i].emplace_back(i, j, d);
                        G[j].emplace_back(j, i, d);
                    }
                }
            }
        }

        auto dis = dijkstra(G, start);

        double ans = numeric_limits<double>::max();
        for (int i = 0; i < dis.size(); ++i) {
            if (pp[i].first == pp[i].second) {
                chmin(ans, dis[i]);
            }
        }

        cout << ans << endl;
    }

    return 0;
}



Measured memory_bytes: 40648