Problem: You are given two rectangles on a plane. The centers of both rectangles are located in the origin of coordinates (meaning the center of the rectangle's symmetry). The first rectangle's sides are parallel to the coordinate axes: the length of the side that is parallel to the Ox axis, equals w, the length of the side that is parallel to the Oy axis, equals h. The second rectangle can be obtained by rotating the first rectangle relative to the origin of coordinates by angle α.

<image>

Your task is to find the area of the region which belongs to both given rectangles. This region is shaded in the picture.

Input

The first line contains three integers w, h, α (1 ≤ w, h ≤ 106; 0 ≤ α ≤ 180). Angle α is given in degrees.

Output

In a single line print a real number — the area of the region which belongs to both given rectangles.

The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.

Examples

Input

1 1 45


Output

0.828427125


Input

6 4 30


Output

19.668384925

Note

The second sample has been drawn on the picture above.

Solution (in JAVA):

Solution:
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;


public class CF280A2 {

    static final double EPS = 1e-9;

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        double w = sc.nextInt();
        double h = sc.nextInt();
        double a = Math.toRadians(sc.nextInt());

        Point[] p = new Point[] {
                new Point(-w / 2, +h / 2), new Point(-w / 2, -h / 2),
                new Point(+w / 2, -h / 2), new Point(+w / 2, +h / 2), };

        AffineTransform transform = AffineTransform.getRotateInstance(a);
        Point[] q = new Point[4];
        for (int i = 0; i < 4; i++) {
            q[i] = new Point(0, 0);
            transform.transform(p[i], q[i]);
        }

        ArrayList<Point> area = convexIntersection(p, q);
//        System.out.println(area);

        double ans = 0;
        for (int i = 0; i < area.size(); i++) {
            ans += (area.get(i).x - area.get((i + 1) % area.size()).x)
                    * (area.get(i).y + area.get((i + 1) % area.size()).y) / 2;
        }
        System.out.printf("%.10f%n", Math.abs(ans));
    }

    static class Point extends Point2D.Double {

        public Point(double x, double y) {
            super(x, y);
        }

        double dot(Point p) {
            return x * p.x + y * p.y;
        }

        double cross(Point p) {
            return x * p.y - y * p.x;
        }

        double distanceSqr() {
            return x * x + y * y;
        }

        Point add(Point p) {
            return new Point(x + p.x, y + p.y);
        }

        Point multiply(double k) {
            return new Point(k * x, k * y);
        }

        Point subtract(Point begin) {
            return new Point(x - begin.x, y - begin.y);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null) return false;
            if (getClass() != obj.getClass()) return false;
            Point other = (Point) obj;
            if (!approxEquals(x, other.x)) return false;
            if (!approxEquals(y, other.y)) return false;
            return true;
        }
    }

    static final Comparator<Point> XY_COMPARATOR = new Comparator<Point>() {
        @Override
        public int compare(Point o1, Point o2) {
            if (!approxEquals(o1.x, o2.x)) return (int) Math.signum(o1.x - o2.x);
            if (!approxEquals(o1.y, o2.y)) return (int) Math.signum(o1.y - o2.y);
            return 0;
        }
    };

    static boolean approxEquals(double a, double b) {
        return Math.abs(a - b) < EPS;
    }

    /**
     * @return \u7e5d\u5436\u3051\u7e5d\u533b\u039d a->b \u7e3a\u4e5d\uff49\u9695\u4e5d\u203b\u7e5d\u5436\u3051\u7e5d\u533b\u039d b->c \u7e3a\u609f\uff77\uff66\u8737\u4ee3\u2033\u7e3a\uff6a\u7e67\ufffd\u7e32\u221d\u627f\u8737\u4ee3\u2033\u7e3a\uff6a\u7e67\ufffd1
     * @see http://www.prefield.com/algorithm/geometry/ccw.html
     */
    static int ccw(Point a, Point b, Point c) {
        b = b.subtract(a);
        c = c.subtract(a);
        if (b.cross(c) > EPS) return +1;                  // counter clockwise
        if (b.cross(c) + EPS < 0) return -1;              // clockwise
        if (b.dot(c) + EPS < 0) return +2;                // c--a--b on line and a!=c
        if (b.distanceSqr() < c.distanceSqr()) return -2; // a--b--c on line or a==b
        return 0;                                         // a--c--b on line or b==c
    }

    /*
     * @see http://www.prefield.com/algorithm/geometry/intersection.html
     */
    static boolean intersectsSS(Point a1, Point a2, Point b1, Point b2) {
        // \u83a0\u5075\uff1e\u7e3a\uff6e\u9076\uff6f\u8f64\uff79\u7e3a\u745a\ufffd\u9704\uff6b\u7e3a\uff6e\u87fe\uff66\u873f\uff73\u7e3a\uff6b\u86fb\ufffd\u00b0\u7e67\u5f8c\u203b\u7e3a\ufffd\uff4b\u7e3a\uff6a\u7e67\u6db2rue
        return ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0
                && ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0;
    }

    static boolean intersectsSP(Point a1, Point a2, Point b) {
        return ccw(a1, a2, b) == 0;
    }

    /** @see http://www.deqnotes.net/acmicpc/2d_geometry/lines#intersection_of_lines */
    static Point crosspointLL(Point a1, Point a2, Point b1, Point b2) {
        // \u7e5d\u5436\u3051\u7e5d\u533b\u039da\u7e3a\uff6e\u9adf\uff77\u7e3a\u8f14\uff52d1/d2\u86df\u962a\u2606\u7e67\u4e5d\u2192\u9036\uff74\u90b1\u5598\u7e3a\uff6b\u8b17\uff65\u7e3a\u5436\uff4b\u7e67\u533b\u2267\u7e3a\uff6bd1,d2\u7e67\u5b9a\uff68\uff6d\u87b3\ufffd
        Point a = a2.subtract(a1);
        Point b = b2.subtract(b1);
        double d1 = b.cross(b1.subtract(a1));
        double d2 = b.cross(a);
        if (Math.abs(d1) < EPS && Math.abs(d2) < EPS) return a1;  // same line
        return new Point(a1.x + d1 / d2 * a.x, a1.y + d1 / d2 * a.y);
    }

    /**
     * O(log n)
     * \u8703\uff78\u879f\u590a\uff67\u8c9e\uff7d\uff62\u7e3a\uff6f\u90b5\uff6e\u9a3e\ufffd\uff20\u7e3a\uff66\u7e3a\ufffd\u2191\u7e3a\ufffd\uff05\u7e3a\uff68
     * 
     * @return \u8700\ufffd\u039a\u7e3a\uff6b\u87c4\u4f1c\u60e0\u7e3a\u5436\uff4b\u7e3a\uff6a\u7e67\ufffd\u7e32\u222b\uff77\u58fc\ufffd\u8373\u7feb\u2191\u7e67\ufffd\u7e32\u221d\uff64\u591c\u039a\u7e3a\uff6a\u7e67\ufffd
     * @see http://www.prefield.com/algorithm/geometry/convex_contains.html
     * @see http://stackoverflow.com/a/5224119/897061
     */
    static int isInCcwConvex(Point p, Point[] polygon) {
        int n = polygon.length;
        // \u8703\uff78\u8816\uff62\u7e3a\uff6e\u8700\ufffd\u305b\u7e67\u5243\uff7b\uff7b\u8ae2\u4e0a\u2193\u9a55\uff78\u7e3a\uff76
        Point g = polygon[0].add(polygon[n / 3]).add(polygon[n * 2 / 3])
                .multiply(1.0 / 3);
        if (g.equals(p)) return 1;
        Point gp = p.subtract(g);

        int l = 0;
        int r = n;
        while (l + 1 < r) {  // \u8f64\uff79g\u7e3a\uff6b\u7e67\u533b\uff4a\u9b06\u4f1c\u6cba\u7e67\u5075\u305d\u7e67\uff6f\u7e67\uff7f\u7e3a\uff6b\u86fb\ufffd\u7261\u7e3a\u52b1\ufffd\u83a0\u609f\ufffd\u8b17\uff62\u908f\uff62\u7e3a\uff67\u8f64\uff79p\u7e3a\uff6e\u7e3a\u3085\uff4b\u7e67\uff7b\u7e67\uff6f\u7e67\uff7f\u7e67\u5448\u723e\u7e3a\ufffd
            int mid = (l + r) / 2;
            Point gl = polygon[l].subtract(g);
            Point gm = polygon[mid].subtract(g);
            if (gl.cross(gm) > 0) { // gl\u7e3a\u4e5d\uff49gm\u7e3a\uff78\u7e3a\uff6e\u7e67\uff7b\u7e67\uff6f\u7e67\uff7f\u7e3a\u7881\u5f37\u9697\u5075\u3012\u7e3a\u3085\uff4b
                // gl\u7e3a\u4e5d\uff49gm\u7e3a\uff6e\u907d\ufffd\u5cc7\u7e3a\uff6b\u8f64\uff79p\u7e3a\u5f8c\u2260\u7e67\u4e5d\u00b0\u96b1\uff7f\u7e3a\uff79\u7e67\ufffd
                if (gl.cross(gp) >= 0 && gm.cross(gp) <= 0) r = mid;
                else l = mid;
            }
            else {
                // \u9a6a\uff6d\u9697\u8c9e\ufffd\u7e3a\uff6b\u8f64\uff79\u7e3a\u5f8c\u2260\u7e67\u4e5d\u00b0\u96b1\uff7f\u7e3a\uff79\u7e67\ufffd
                if (gm.cross(gp) >= 0 && gl.cross(gp) <= 0) l = mid;
                else r = mid;
            }
        }
        r %= n;
        double cross = polygon[l].subtract(p).cross(polygon[r].subtract(p));
        return approxEquals(cross, 0) ? 2 : cross < 0 ? 0 : 1;
    }

    /**
     * @see http://web.archive.org/web/20110317231822/http://cgm.cs.mcgill.ca/~godfried/teaching/cg-projects/97/Plante/
     *      CompGeomProject-EPlante/algorithm.html
     */
    static ArrayList<Point> convexIntersection(Point[] p, Point[] q) {
        int n = p.length;
        int m = q.length;
        Point minP = Collections.min(Arrays.asList(p), XY_COMPARATOR);
        Point minQ = Collections.min(Arrays.asList(q), XY_COMPARATOR);
        int argminP = Arrays.asList(p).indexOf(minP);
        int argminQ = Arrays.asList(q).indexOf(minQ);
        int comp = XY_COMPARATOR.compare(minP, minQ);
        int i = argminP;
        int j = argminQ;
        if (comp == 0) {
            // \u8b5b\ufffd\uff70\u4e0a\ufffd\u9695\u222b\uff74\ufffd\u2032\u8373\ufffd\ufffd\u7e3a\u5436\uff4b\u7e3a\uff6a\u7e67\u5ce8\ufffd2\u7e3a\uff64\u7e3a\uff6e\u8703\uff78\u879f\u590a\uff67\u8c9e\uff7d\uff62\u7e67\u8c9e\u9154\u8b4e\u3085\u2193\u9a3e\uff72\u7e67\u8599\u3012\u7e3a\ufffd\uffe5
            // \u8b5b\ufffd\ufffd\u7e3a\uff6b\u9695\u4e5d\u25bd\u7e3a\u4e5d\u25b2\u7e3a\u6ebd\u5d8c\u9a55\u6155\u305b\u7e3a\u5fa1\uff7a\uff64\u87fe\uff6e\u9a5b\uff68\u86fb\ufffd\u2192\u7e3a\uff6a\u7e67\ufffd
            do {
                i = (i + 1) % n;
                j = (j + 1) % m;
            } while (i != argminP && p[i].equals(q[j]));
            if (i == argminP) return new ArrayList<Point>(Arrays.asList(p));  // p\u7e3a\uff68q\u7e3a\uff6f\u9072\u5ce8\uff20\u7e3a\ufffd
            return convexIntersectionPhase3(p, q, (i + n - 1) % n, (j + m - 1) % m);
        }
        if (comp > 0) {  // p\u7e3a\u7e4b\u7e67\u533b\uff4a\u873f\uff73(\u7e3a\u3085\uff4b\u7e3a\ufffd\ufffd\u8373\ufffd\u7e3a\uff6b\u7e3a\u3085\uff4b
            return convexIntersection(q, p);  // \u8ae4\ufffd\u03a3\u7e3a\uff6bswap
        }

        // p\u7e3a\u7e4b\u7e67\u533b\uff4a\u87fe\uff66\u7e3a\uff6b\u7e3a\u3085\uff4b\u7e3a\uff6a\u7e67\u5ce8\u304f\u7e5d\uff63\u7e5d\uff6a\u7e5d\u4ee3\ufffd\u7e3a\u5436\uff4b
        int count = 0;
        do {
            Point pVec = p[next(i, n)].subtract(p[i]);
            Point qVec = q[next(j, m)].subtract(q[j]);
            double cross = pVec.cross(qVec);
            Point dir = cross > 0 ? pVec : qVec;
            if (dir.cross(q[j].subtract(p[i])) < EPS) {
                // p\u7e3a\uff6e\u7e67\uff6d\u7e5d\uff63\u7e5d\uff6a\u7e5d\u4ee3\ufffd\u7e3a\u4e5d\uff49\u9695\u4e5d\u203bq\u7e3a\uff6e\u7e67\uff6d\u7e5d\uff63\u7e5d\uff6a\u7e5d\u4ee3\ufffd\u7e3a\uff6f\u873f\uff73\u86db\uff74\u7e3a\u5036\uff78\ufffd\u5ce9\u90b1\u58fb\uff78\u7feb\u2193\u7e3a\u3085\uff4b
                // \u7e3a\u8599\uff05\u7e3a\u7d99okect lid
                return convexIntersectionPhase2(p, q, i, j);
            }

            if (cross > -EPS) i = next(i, n);
            if (cross < EPS) j = next(j, m);
        } while (count++ < n + m);

        // \u8373\ufffd\u6349\u8389\uff65\u8373\u7feb\uff20\u7e3a\uff66\u7e67\u3085\u304f\u7e5d\uff63\u7e5d\uff6a\u7e5d\u4ee3\ufffd\u7e3a\uff6e\u83f4\u54b2\uff7d\uff6e\u9ae2\uff62\u83eb\u3085\u2032\u879f\u5ce8\uff4f\u7e67\u5ce8\u2191\u7e3a\u4e5d\u25b2\u7e3a\u6e98\ufffd\u7e3a\uff67q\u7e3a\uff6fp\u7e3a\uff6e\u8700\ufffd\u039a\u7e3a\uff6b\u7e3a\u3085\uff4b
        return new ArrayList<Point>(Arrays.asList(q));
    }

    private static int next(int i, int n) {
        return (i + 1) % n;
    }

    private static ArrayList<Point> convexIntersectionPhase2(Point[] p, Point[] q, int i,
            int j) {
        int n = p.length;
        int m = q.length;
        // pocket lid\u7e3a\uff6e\u8373\uff6d\u7e3a\uff6b\u83a0\uff64\u87fe\uff6e\u9a5b\uff68\u86fb\ufffd\u2032\u7e3a\u3085\uff4b\u7e3a\uff6f\u7e3a\u58f9\u2191\u7e3a\uff6e\u7e3a\uff67\u8b17\uff62\u7e3a\ufffd
        // \u8389\u7feb\ufffd\u95a0\uff73\u7e3a\uff6e\u8373\uff6d\u7e3a\uff6b\u7e3a\ufffd\uff4b
        // \u8711\u80b4\u7f72\u8b5a\uff61\u8389\uff76\u7e67\u533b\uff4ap[0]\u7e3a\uff6f\u8708\uff71\u9a3e\u5910\u039a\u86fb\ufffd\uff64\u60b6\u2191\u7e3a\uff6e\u7e3a\uff67\u7e32\uff5d\u7e3a\uff6f\u7e67\uff64\u7e5d\uff73\u7e5d\ufffd\u30e3\u7e67\uff6f\u7e67\uff79\u7e67\u5e1d\ufffd\u7e67\u221a\uff4b\u7e3a\u6590\u2192\u7e3a\uff6b\u95a0\uff73\u7e3a\uff6e\u8782\uff65\u7e3a\uff6b\u9666\u5f8c\u2033\u7e32\ufffd
        // q\u7e3a\uff6f\u7e67\uff64\u7e5d\uff73\u7e5d\ufffd\u30e3\u7e67\uff6f\u7e67\uff79\u7e67\u5448\u7dbe\u7e3a\u5436\uff03\u7e3a\uff68\u7e3a\uff6b\u8782\uff65\u7e3a\uff78\u9666\u5f8c\uffe5
        boolean updated;
        int count = 0;
        do {
            updated = false;
            while (count < n + m
                    && p[next(i, n)].subtract(p[i]).cross(
                            q[(j + m - 1) % m].subtract(p[i])) < -EPS) {
                j = (j + m - 1) % m;
                updated = true;
                count++;
            }
            while (count < n + m
                    && q[(j + m - 1) % m].subtract(q[j]).cross(
                            p[next(i, n)].subtract(q[j])) > EPS) {
                i = next(i, n);
                updated = true;
                count++;
            }
        } while (updated);
        if (count >= n + m) {  // \u8708\uff71\u9a3e\u5910\u039a\u86fb\ufffd\u2191\u7e3a\uff69\u7e3a\uff6a\u7e3a\u4e5d\u25b2\u7e3a\ufffd
            return new ArrayList<Point>();
        }
        j = (j + m - 1) % m;  // q\u7e67\u5448\u51fe\u96aa\u4ea5\u5c53\u7e67\u7feb\u2193\u95a0\ufffd\u2234\u7e3a\uff66\u7e3a\ufffd\u25c6\u7e3a\uff6e\u7e3a\uff67\u8b0c\uff7b\u7e3a\ufffd
        return convexIntersectionPhase3(p, q, i, j);
    }

    private static ArrayList<Point> convexIntersectionPhase3(Point[] p, Point[] q, int i,
            int j) {
        // \u8708\uff77\u83f4\u934b\u566a\u7e3a\uff6a\u8708\uff71\u9a3e\u5910\u039a\u86fb\ufffd\u2032\u9695\u4e5d\u25bd\u7e3a\u4e5d\u25b2\u7e3a\u6e98\ufffd\u7e3a\uff67\u7e32\u221a\u2260\u7e3a\uff68\u7e3a\uff6fSpaghetti Source\u7e3a\uff6b\u7e3a\u3085\uff4b\u7e67\u533b\u2267\u7e3a\uff6b
        // \u83a0\uff64\u83a0\u8c9e\uff7c\uff67\u7e67\u5075\u30e8\u7e5d\uff6c\u7e5d\uff7c\u7e67\uff79\u7e3a\u52b1\u203b\u7e3a\ufffd\uffe0\u7e3a\uff70\u7e3a\ufffd\uff1e
        int n = p.length;
        int m = q.length;
        assert intersectsSS(p[i], p[next(i, n)], q[j], q[next(j, m)]);

        ArrayList<Point> intersection = new ArrayList<Point>();
        Point crossP = crosspointLL(p[i], p[next(i, n)], q[j], q[next(j, m)]);
        intersection.add(crossP);
        boolean pIsInQ = p[next(i, n)].subtract(p[i]).cross(q[next(j, m)].subtract(q[j])) <= 0;
        if (pIsInQ && !p[next(i, n)].equals(q[j])) j = next(j, m);
        else i = next(i, n);

        // O(n+m)\u7e3a\uff6e\u7e3a\uff64\u7e67\u3085\uff4a\u7e3a\u85ab(nlogm + mlogn)\u7e3a\ufffd\u25b2\u7e3a\u6eaa\ufffd\u7e3a\u8599\uff4c\u7e3a\uff6a\u7e67\u753b\u6019\u86fb\u6634\u00b0\u7e67\u753b\u52f8\u9a3e\u58f9\u2193\u8703\uff78\u86f9\ufffd\uff7d\u61ca\u25b2\u7e3a\u6ed3\u5a7f\u7e3a\u68a7\uff65\uff7d
        // \u7e67\uff6d\u7e5d\uff63\u7e5d\uff6a\u7e5d\u4ee3\ufffd\u7e3a\uff67\u83a0\uff64\u87fe\uff6e\u8f64\uff79\u8708\uff68\u86fb\u73b2\u5acc\u7e3a\u5436\uff4c\u7e3a\uff70O(n+m)\u7e3a\uff6b\u7e3a\uff6a\u7e67\u4e5d\uff49\u7e3a\u52b1\uff1e
        do {
            Point nextP = p[next(i, n)];
            Point nextQ = q[next(j, m)];
            if (pIsInQ) {
                int inState = isInCcwConvex(nextP, q);
                if (inState == 1
                        || (inState == 2 && nextP.subtract(p[i]).cross(
                                nextQ.subtract(q[j])) < EPS)) {
                    intersection.add(nextP);
                }
                else {
                    // \u83a0\uff64\u87fe\uff6e\u7e3a\u5436\uff4b\u970e\uff7a\u7e3a\u745a\uff66\u4e5d\u25bd\u7e3a\u4e5d\uff4b\u7e3a\uff7e\u7e3a\uff67q\u7e3a\uff6e\u970e\uff7a\u7e67\u5e1d\ufffd\u7e67\u221a\uff4b
                    while (!intersectsSS(p[i], nextP, q[j], q[next(j, m)])
                            || p[i].equals(q[j]))
                        j = (j + 1) % m;
                    nextQ = q[next(j, m)];
                    Point c = crosspointLL(p[i], nextP, q[j], nextQ);
                    if (approxEquals(nextP.subtract(p[i]).cross(nextQ.subtract(q[j])), 0)) {  // 2\u7e5d\u5436\u3051\u7e5d\u533b\u039d\u7e3a\u609f\u9154\u8373\ufffd\u5ce9\u90b1\u58fb\uff78\ufffd
                        // q\u7e3a\uff6b\u7e3a\uff68\u7e3a\uff63\u7e3a\uff66\u8b5b\ufffd\uff42\u9a3e\uff72\u7e67\u8599\u25a1\u8763\uff74\u8b07\ufffd\u2208\u9666\u5f8c\uffe5\u7e3a\uff79\u7e3a\ufffd
                        if (intersectsSP(p[i], nextP, nextQ)) c = nextQ;
                        else c = nextQ.subtract(nextP).distanceSqr() > nextQ.subtract(
                                p[i]).distanceSqr() ? p[i] : nextP;
                    }
                    intersection.add(c);
                    pIsInQ = false;
                }
                i = (i + 1) % n;
            }
            else {
                int inState = isInCcwConvex(nextQ, p);
                if (inState == 1
                        || (inState == 2 && nextQ.subtract(q[j]).cross(
                                nextP.subtract(p[i])) < EPS)) {
                    intersection.add(nextQ);
                }
                else {
                    while (!intersectsSS(p[i], p[next(i, n)], q[j], nextQ)
                            || p[i].equals(q[j]))
                        i = (i + 1) % n;
                    nextP = p[next(i, n)];
                    Point c = crosspointLL(p[i], nextP, q[j], nextQ);
                    if (approxEquals(nextP.subtract(p[i]).cross(nextQ.subtract(q[j])), 0)) {  // 2\u7e5d\u5436\u3051\u7e5d\u533b\u039d\u7e3a\u609f\uff79\uff73\u9666\ufffd
                        // p\u7e3a\uff6b\u7e3a\uff68\u7e3a\uff63\u7e3a\uff66\u8b5b\ufffd\uff42\u9a3e\uff72\u7e67\u8599\u25a1\u8763\uff74\u8b07\ufffd\u2208\u9666\u5f8c\uffe5\u7e3a\uff79\u7e3a\ufffd
                        if (intersectsSP(q[j], nextQ, nextP)) c = nextP;
                        else c = nextP.subtract(nextQ).distanceSqr() > nextP.subtract(
                                q[j]).distanceSqr() ? q[j] : nextQ;
                    }
                    intersection.add(c);
                    pIsInQ = true;
                }
                j = (j + 1) % m;
            }
        } while (intersection.size() <= (n + m) * 2
                && !intersection.get(0).equals(intersection.get(intersection.size() - 1)));
        if (intersection.size() > (n + m) * 2) throw new IllegalStateException("A BUG");

        // \u8f9f\uff61\u9b27\ufffd\u2191\u970e\uff7a\u7e67\u5448\uff76\u533b\u2606
        ArrayList<Point> intersection2 = new ArrayList<Point>();
        for (int k = 0; k < intersection.size(); k++) {
            if (intersection2.size() < 2
                    || ccw(intersection2.get(intersection2.size() - 2), intersection2
                            .get(intersection2.size() - 1), intersection.get(k)) == 1) {
                intersection2.add(intersection.get(k));
            }
        }
        if (intersection2.size() > 1
                && intersection2.get(0).equals(
                        intersection2.get(intersection2.size() - 1))) intersection2
                .remove(intersection2.size() - 1);
        return intersection2;
    }

}