const double PI = 3.14159265358979323846;
const double EPS = 1e-8;

struct point
{
    double x, y;

    point() : x(0), y(0) {}
    point(double _x, double _y) : x(_x), y(_y) {}

    double dist(point b)
    {
        return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
    }

    bool operator==(point b)
    {
        return fabs(x - b.x) <= EPS && fabs(y - b.y) <= EPS;
    }

    bool operator<(point b) const
    {
        if (x < b.x - EPS)
            return true;
        if (fabs(x - b.x) <= EPS && y < b.y - EPS)
            return true;
        return false;
    }
};


struct line
{
    double a, b, c;

    line() : a(0), b(0), c(0) {}
    line(double _a, double _b, double _c) : a(_a), b(_b), c(_c) {}
    line(point p1, point p2) : a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {}

    bool parallel(line x)
    {
        return a * x.b - b * x.a == 0;
    }

    point cross(line x)
    {
        point ans;
        ans.x = -((c * x.b - x.c * b) / (a * x.b - x.a * b));
        ans.y = -((a * x.c - x.a * c) / (a * x.b - x.a * b));
        return ans;
    }

    double dist_to_point(point p)
    {
        double res = a * p.x + b * p.y + c;
        res /= sqrt(a * a + b * b);
        return res;
    }
};


struct vt
{
    double x, y;

    vt() : x(0), y(0) {}
    vt(double _x, double _y) : x(_x), y(_y) {}
    vt(point a, point b) : x(b.x - a.x), y(b.y - a.y) {}

    void norm()
    {
        double length = len();
        x /= length;
        y /= length;
    }

    bool operator==(vt& v)
    {
        vt copy_a(x, y), copy_b = v;
        copy_a.norm();
        copy_b.norm();
        return point(copy_a.x, copy_a.y) == point(copy_b.x, copy_b.y);
    }

    vt operator+(vt& v)
    {
        return vt(x + v.x, y + v.y);
    }

    vt operator-(vt& v)
    {
        return vt(x - v.x, y - v.y);
    }

    double operator*(vt& v)
    {
        return x * v.x + y * v.y;
    }

    vt operator*(double k)
    {
        return vt(k * x, k * y);
    }

    double operator^(vt& v)
    {
        return x * v.y - v.x * y;
    }

    vt operator-()
    {
        return vt(-x, -y);
    }

    double angle(vt& v)
    {
        return atan2((vt(x, y) ^ v), (vt(x, y) * v));
    }

    double len()
    {
        return sqrt((double)(x * x + y * y));
    }
};


struct segm
{
    point p1, p2;

    segm() : p1(0, 0), p2(0, 0){}
    segm(double _x1, double _y1, double _x2, double _y2) : p1(_x1, _y1), p2(_x2, _y2){}
    segm(point a, point b) : p1(a), p2(b){}

    double len()
    {
        return sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
    }

    bool operator==(segm& s)
    {
        return s.p1 == p1 && s.p2 == p2;
    }

    double dist(point p)
    {
        vt a1(p1, p), b1(p1, p2);
        vt a2(p2, p), b2(p2, p1);
        if (a1 * b1 >= 0 && a2 * b2 >= 0)
        {
            return fabs((a1 ^ b2) / len());
        }
        else
        {
            return min(p.dist(p1), p.dist(p2));
        }
    }

    line to_line()
    {
        return line(p1, p2);
    }

    bool is_bounding_box_cross(segm s)
    {
        point a = p1, b = p2, c = s.p1, d = s.p2;

        //x
        int ax = a.x, bx = b.x, cx = c.x, dx = d.x;
        if (ax > bx)
            swap(ax, bx);
        if (cx > dx)
            swap(cx, dx);
        if (max(ax, cx) > min(bx, dx))
            return false;

        //y
        int ay = a.y, by = b.y, cy = c.y, dy = d.y;
        if (ay > by)
            swap(ay, by);
        if (cy > dy)
            swap(cy, dy);
        if (max(ay, cy) > min(by, dy))
            return false;

        if (b < a)
            swap(a, b);
        if (d < c)
            swap(c, d);

        return true;
    }

    bool cross(segm b, segm& res)
    {
        segm pre_res;

        vt p1_p3 = vt(p1, b.p1),
            p1_p2 = vt(p1, p2),
            p1_p4 = vt(p1, b.p2),
            p3_p1 = vt(b.p1, p1),
            p3_p4 = vt(b.p1, b.p2),
            p3_p2 = vt(b.p1, p2);
        bool ok = ((p1_p3 ^ p1_p2) * (p1_p4 ^ p1_p2) <= 0 &&
            (p3_p1 ^ p3_p4) * (p3_p2 ^ p3_p4) <= 0 && is_bounding_box_cross(b));

        if (!ok)
            return false;

        line x1(p1, p2);
        line x2(b.p1, b.p2);

        if (x1.parallel(x2))
        {
            point left, right;

            point A = p1, B = p2, C = b.p1, D = b.p2;

            if (D < C)
                swap(C, D);
            if (B < A)
                swap(A, B);

            left = max(A, C);
            right = min(B, D);

            res = segm(left, right);
        }
        else
        {
            point x = x1.cross(x2);
            res = segm(x, x);
        }
        return true;
    }
};


double cosine_by_sine(double sine)
{
    return sqrt(1 - sine * sine);
}

double sine_by_cosine(double cosine)
{
    return sqrt(1 - cosine * cosine);
}

double rad_to_deg(double ang)
{
    return (180. * ang) / PI;
}