#ifndef ENV_AC
    #define ENV_AC
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    #include <fstream>
    #include <iostream>
    #include <sstream>
    #include <iomanip>
    #include <algorithm>
    #include <bitset>
    #include <array>
    #include <vector>
    #include <queue>
    #include <set>
    #include <cmath> // 変数名にy1が使えなくなるかも…。
    #include <map>
    #include <unordered_map>
    #include <unordered_set>
    #include <limits>
    #include <functional>
    #include <string>
    #include <ext/rope>

    using int128_t = __int128_t;
    std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
        int64_t tmp; input >> tmp; value = tmp;
        return input;
    }
    std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
        output << (int64_t)value;
        return output;
    }

    namespace std {
        template<> class hash<int128_t>{
            public:
            size_t operator () ( const int128_t &x ) const {
                int64_t INF64 = std::numeric_limits<int64_t>::max();
                int64_t y1 = x / INF64;
                int64_t y2 = x % INF64;
                return hash<int64_t>()(y1) ^ hash<int64_t>()(y2);
            }
        };
    }

    int128_t imax(const int128_t a, const int128_t b) { return std::max(a, b); } // std::max, std::min は型が違うとエラーになるため、ラッパーを作る。
    int128_t imin(const int128_t a, const int128_t b) { return std::min(a, b); }
    int128_t iabs(const int128_t x) { return 0 <= x ? x : -x; }
    int128_t ipow(const int128_t x, const int128_t n) { int128_t ret = 1; for (int i = 0; i < n; i++) { ret *= x; } return ret; }

    template <int128_t mod> class Mod_Int {
        public:
        int128_t val;

        void calc() {
            if (val < 0) { val += ((iabs(val) + mod) / mod) * mod; }
            val %= mod;
        }
        Mod_Int(const int128_t _val = 0) { val = _val; calc(); }
        int128_t INT() { return val; } // 使用は非想定
        int128_t MOD() { return mod; } // 使用は非想定
        Mod_Int operator-() const { return Mod_Int(-val); }
        Mod_Int operator+(const Mod_Int &r) const { return Mod_Int(val + r.val); }
        Mod_Int operator-(const Mod_Int &r) const { return Mod_Int(val - r.val); }
        Mod_Int operator*(const Mod_Int &r) const { return Mod_Int(val * r.val); }
        //Mod_Int operator/(const Mod_Int &r) const { return ; } // ユークリッド互除法を使うべきだが保留。
        Mod_Int& operator+=(const Mod_Int &r) { val += r.val; calc(); return *this; }
        Mod_Int& operator-=(const Mod_Int &r) { val -= r.val; calc(); return *this; }
        Mod_Int& operator*=(const Mod_Int &r) { val *= r.val; calc(); return *this; }
        Mod_Int& operator++() { return (*this) += 1; }
        Mod_Int& operator--() { return (*this) -= 1; }
        Mod_Int operator++(int) { Mod_Int tmp = *this; ++*this; return tmp; }
        Mod_Int operator--(int) { Mod_Int tmp = *this; --*this; return tmp; }
        bool operator==(const Mod_Int &r) const { return val == r.val; }
        bool operator!=(const Mod_Int &r) const { return val != r.val; }

        friend std::istream &operator>>(std::istream& input, Mod_Int& r) { 
            int128_t tmp; input >> tmp;
            r = Mod_Int(tmp);
            return input;
        }
        friend std::ostream &operator<<(std::ostream& output, const Mod_Int& r) { 
            output << r.val;
            return output;
        }
    };

    #define rep(i, begin, end) for(int64_t i = ((int64_t)begin); i <= ((int64_t)end); i++) // (int64_t)end としておくと、end = v.size() - 2 みたいな入力で、v.size()が1でも正常(end = -1になる）に挙動する。
    #define rev(i, begin, end) for(int64_t i = ((int64_t)begin); ((int64_t)end) <= i; i--) // int128_tにすると、3重ループでコンパイルエラーになったのでint64_tにしておく。

    #define input1(begin, end, v1) v1.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i]; }
    #define input2(begin, end, v1, v2) v1.resize((end)+1); v2.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i]; } 
    #define input3(begin, end, v1, v2, v3) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i]; }
    #define input4(begin, end, v1, v2, v3, v4) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i]; } 
    #define input5(begin, end, v1, v2, v3, v4, v5) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); v5.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i] >> v5[i]; }  
    // input_arrayはbegin = 0のときのみ動作確認。Aの要素の型をテンプレートにして関数にしたほうが丁寧かもしれない。
    #define input_array(begin, N, M, A) A.resize((begin)+(N)); for (int i = 0; i < (begin)+(N); i++) { A[i].resize((begin)+(M)); } for (int i = begin; i < (begin)+(N); i++) { for (int j = begin; j < (begin)+(M); j++) { std::cin >> A[i][j]; }}

    std::vector<int> irange(const int begin, const int end) {
        std::vector<int> ret; for (int i = begin; i <= end; i++) { ret.push_back(i); }
        return ret;
    }

    template <typename T>
    std::vector<T> accumulate_vec(const std::vector<T>& vec, const bool reverse = false) {
        std::vector<T> ret; ret.resize(vec.size());
        if (reverse == false) {
            ret[0] = vec[0];
            for (int i = 1; i < ret.size(); i++) {
                ret[i] = ret[i-1] + vec[i];
            }
        } else {
            ret[ret.size()-1] = vec[ret.size()-1];
            for (int i = ret.size() - 2; 0 <= i; i--) {
                ret[i] = ret[i+1] + vec[i];
            }
        }
        return ret;
    }

    template <typename T>
    void printvec(const std::vector<T>& vec) {
        for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
    }
#endif

//--code begin--

// 誤差を考慮して足し算を行う
int128_t add(const int128_t a, const int128_t b) {
    return a + b;
}

// 二次元ベクトル構造体
struct Point {
    int128_t x, y;
    int128_t id;
    Point() {}
    Point(int128_t x, int128_t y) : x(x), y(y) {}
    Point operator + (const Point p) const {
        return Point(add(x, p.x), add(y, p.y));
    }
    Point operator - (const Point p) const {
        return Point(add(x, -p.x), add(y, -p.y));
    }
    Point operator * (const int128_t d) const {
        return Point(x * d, y * d);
    }
    int128_t radian() const { // 角度　-πからπまでの値をとる。
        return atan2(y, x);
    }
    int128_t dot(const Point p) const { // 内積
        return add(x * p.x, y * p.y);
    }
    int128_t det(const Point p) const { // 外積
        return add(x * p.y, -y * p.x);
    }
};

bool cmp_x(const Point& p, const Point& q) {
    if (p.x != q.x) {
        return p.x < q.x;
    } else {
        return p.y < q.y;
    }
}

// 凸包を求める
// Pointでのsortはdouble型で不安なため、整数方のうちにソートしておく。
// 引数であるpsはソートされている前提。
std::vector<Point> convex_hull(const std::vector<Point>& ps) {
    //std::sort(ps, ps + n, cmp_x);
    int128_t k = 0;  // 凸包の頂点数
    std::vector<Point> qs(ps.size()*2); // 構築中の凸包
 
    // 下側凸包の作成
    for (int128_t i = 0; i < ps.size(); i++) {
        while (k > 1 && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) {
            // qs[k-2] -> qs[k-1] -> ps[i] と進む際に時計周りに回転する場合（qs[k-1]がいらないのでkを減らすことで、qs[k-1]を置き換える。）
            k--;
        }
        qs[k++] = ps[i];
    }
 
    // 上側凸包の作成
    for (int128_t i = ps.size() - 2, t = k; i >= 0; i--) {
        while (k > t && (qs[k-1] - qs[k-2]).det(ps[i] - qs[k-1]) <= 0) {
            k--;
        }
        qs[k++] = ps[i];
    }
 
    // この時、qs[k-1]は上側凸包を作成した際にps[0]が入っていて、不要なので削る。
    qs.resize(k-1);
    return qs;
}

int128_t N;
std::vector<int128_t> x, y;
//std::string ;
//std::vector<std::string> ;
//double ;
//std::vector<double> ;

//const int128_t MAX_N = ;
//const int128_t MOD = ;
//const int128_t INF = std::numeric_limits<int64_t>::max(); const int128_t NEG_INF = std::numeric_limits<int64_t>::min();
//using pair = std::pair<int64_t, int>;
//using mnt = Mod_Int<MOD>;

int main(int argc, char **argv) {
    std::cin.tie(0);
   	std::ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(15);

    std::cin >> N;
    input2(1, N, x, y);

    std::vector<Point> h;
    h.push_back(Point(0, 0));

    rep (i, 1, N) {
        int128_t cs = h.size();
        rep (j, 0, cs - 1) {
            h.push_back(h[j] + Point(x[i], y[i]));
        }
        std::sort(h.begin(), h.end(), [&](Point p1, Point p2){
            if (p1.x != p2.x) {
                return p1.x < p2.x;
            } else {
                return p1.y < p2.y;
            }
        });
        h = convex_hull(h);
    }

    double ret = 0.0;
    for (Point p : h) {
        double tmp = p.x*p.x + p.y*p.y;
        ret = std::max(ret, std::sqrt(tmp));
    }

    std::cout << ret << std::endl;

    return 0;
}


Measured memory_bytes: 384