You are given two circles. Find the area of their intersection.


-----Input-----

The first line contains three integers x_1, y_1, r_1 ( - 10^9 ≤ x_1, y_1 ≤ 10^9, 1 ≤ r_1 ≤ 10^9) — the position of the center and the radius of the first circle.

The second line contains three integers x_2, y_2, r_2 ( - 10^9 ≤ x_2, y_2 ≤ 10^9, 1 ≤ r_2 ≤ 10^9) — the position of the center and the radius of the second circle.


-----Output-----

Print the area of the intersection of the circles. The answer will be considered correct if the absolute or relative error doesn't exceed 10^{ - 6}.


-----Examples-----
Input
0 0 4
6 0 4

Output
7.25298806364175601379

Input
0 0 5
11 0 5

Output
0.00000000000000000000

Difficulty: interview

Starter code:

Solutions:
#!/usr/bin/env python3
# 600D_circles.py - Codeforces.com/problemset/problem/600/D by Sergey 2015

import unittest
import sys
import math
import decimal

###############################################################################
# Circles Class (Main Program)
###############################################################################


def sin(x):
    decimal.getcontext().prec += 2
    i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    decimal.getcontext().prec -= 2
    return +s


def cos(x):
    decimal.getcontext().prec += 2
    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    decimal.getcontext().prec -= 2
    return +s


def pi():
    decimal.getcontext().prec += 2
    three = decimal.Decimal(3)
    lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
    while s != lasts:
        lasts = s
        n, na = n+na, na+8
        d, da = d+da, da+32
        t = (t * n) / d
        s += t
    decimal.getcontext().prec -= 2
    return +s


def asin(x):
    decimal.getcontext().prec += 2
    b, e = -pi()/2, pi()/2
    while True:
        mid = (b + e) / 2
        if e == mid or b == mid:
            break
        if sin(mid) <= x:
            b = mid
        else:
            e = mid
    decimal.getcontext().prec -= 2
    return +b


def acos(x):
    return pi() / 2 - asin(x)


class Circles:
    """ Circles representation """

    def __init__(self, test_inputs=None):
        """ Default constructor """

        it = iter(test_inputs.split("\n")) if test_inputs else None

        def uinput():
            return next(it) if it else sys.stdin.readline().rstrip()

        # Reading single elements
        [self.xa, self.ya, self.ra] = list(map(decimal.Decimal, uinput().split()))
        [self.xb, self.yb, self.rb] = list(map(decimal.Decimal, uinput().split()))

        decimal.getcontext().prec = 40

        self.l = ((self.xb - self.xa)**2 + (self.yb - self.ya)**2).sqrt()
        self.p = (self.ra + self.rb + self.l)/2

        if self.l >= self.p:
            self.sa = 0
            self.sb = 0
        elif self.ra >= self.p:
            self.sa = 0
            self.sb = self.rb**2 * decimal.Decimal.from_float(math.pi)
        elif self.rb >= self.p:
            self.sa = self.ra**2 * decimal.Decimal.from_float(math.pi)
            self.sb = 0
        else:
            self.aa = 2 * acos(
                (self.ra**2 - self.rb**2 + self.l**2) /
                (2 * self.ra * self.l))
            self.ab = 2 * acos(
                (self.rb**2 - self.ra**2 + self.l**2) /
                (2 * self.rb * self.l))
            self.sa = self.ra**2 * (self.aa - sin(self.aa)) / 2
            self.sb = self.rb**2 * (self.ab - sin(self.ab)) / 2

    def calculate(self):
        """ Main calcualtion function of the class """

        result = self.sa + self.sb

        return str(result)

###############################################################################
# Unit Tests
###############################################################################


class unitTests(unittest.TestCase):

    def test_single_test(self):
        """ Circles class testing """

        # Constructor test
        test = "0 0 4\n6 0 4"
        d = Circles(test)
        self.assertEqual(d.l, 6)

        # Sample test
        self.assertEqual(Circles(test).calculate()[:8], "7.252988")

        # Sample test
        test = "0 0 5\n11 0 5"
        self.assertEqual(Circles(test).calculate(), "0")

        # Sample test
        test = "44721 999999999 400000000\n0 0 600000000"
        self.assertEqual(Circles(test).calculate()[:9], "0.0018834")

        # My tests
        test = ""
        # self.assertEqual(Circles(test).calculate(), "0")

        # Time limit test
        # self.time_limit_test(5000)

    def time_limit_test(self, nmax):
        """ Timelimit testing """
        import random
        import timeit

        # Random inputs
        test = str(nmax) + " " + str(nmax) + "\n"
        numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
        test += "\n".join(numnums) + "\n"
        nums = [random.randint(1, 10000) for i in range(nmax)]
        test += " ".join(map(str, nums)) + "\n"

        # Run the test
        start = timeit.default_timer()
        d = Circles(test)
        calc = timeit.default_timer()
        d.calculate()
        stop = timeit.default_timer()
        print(("\nTimelimit Test: " +
              "{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
              format(stop-start, calc-start, stop-calc)))

def __starting_point():

    # Avoiding recursion limitaions
    sys.setrecursionlimit(100000)

    if sys.argv[-1] == "-ut":
        unittest.main(argv=[" "])

    # Print the result string
    sys.stdout.write(Circles().calculate())

__starting_point()

#!/usr/bin/env python3
# 600D_circles.py - Codeforces.com/problemset/problem/600/D by Sergey 2015

import unittest
import sys
import math
import decimal

###############################################################################
# Circles Class (Main Program)
###############################################################################


def sin(x):
    decimal.getcontext().prec += 2
    i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    decimal.getcontext().prec -= 2
    return +s


def cos(x):
    decimal.getcontext().prec += 2
    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    decimal.getcontext().prec -= 2
    return +s


def pi():
    decimal.getcontext().prec += 2
    three = decimal.Decimal(3)
    lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
    while s != lasts:
        lasts = s
        n, na = n+na, na+8
        d, da = d+da, da+32
        t = (t * n) / d
        s += t
    decimal.getcontext().prec -= 2
    return +s


def asin(x):
    decimal.getcontext().prec += 2
    b, e = -pi()/2, pi()/2
    while True:
        mid = (b + e) / 2
        if e == mid or b == mid:
            break
        if sin(mid) <= x:
            b = mid
        else:
            e = mid
    decimal.getcontext().prec -= 2
    return +b


def acos(x):
    return pi() / 2 - asin(x)


class Circles:
    """ Circles representation """

    def __init__(self, test_inputs=None):
        """ Default constructor """

        it = iter(test_inputs.split("\n")) if test_inputs else None

        def uinput():
            return next(it) if it else sys.stdin.readline().rstrip()

        # Reading single elements
        [self.xa, self.ya, self.ra] = list(map(decimal.Decimal, uinput().split()))
        [self.xb, self.yb, self.rb] = list(map(decimal.Decimal, uinput().split()))

        decimal.getcontext().prec = 20

        self.l = ((self.xb - self.xa)**2 + (self.yb - self.ya)**2).sqrt()
        self.p = (self.ra + self.rb + self.l)/2

        if self.l >= self.p:
            self.sa = 0
            self.sb = 0
        elif self.ra >= self.p:
            self.sa = 0
            self.sb = self.rb**2 * decimal.Decimal.from_float(math.pi)
        elif self.rb >= self.p:
            self.sa = self.ra**2 * decimal.Decimal.from_float(math.pi)
            self.sb = 0
        else:
            self.aa = 2 * acos(
                (self.ra**2 - self.rb**2 + self.l**2) /
                (2 * self.ra * self.l))
            self.ab = 2 * acos(
                (self.rb**2 - self.ra**2 + self.l**2) /
                (2 * self.rb * self.l))
            self.sa = self.ra**2 * (self.aa - sin(self.aa)) / 2
            self.sb = self.rb**2 * (self.ab - sin(self.ab)) / 2

    def calculate(self):
        """ Main calcualtion function of the class """

        result = self.sa + self.sb

        return str(result)

###############################################################################
# Unit Tests
###############################################################################


class unitTests(unittest.TestCase):

    def test_single_test(self):
        """ Circles class testing """

        # Constructor test
        test = "0 0 4\n6 0 4"
        d = Circles(test)
        self.assertEqual(d.l, 6)

        # Sample test
        self.assertEqual(Circles(test).calculate()[:8], "7.252988")

        # Sample test
        test = "0 0 5\n11 0 5"
        self.assertEqual(Circles(test).calculate(), "0")

        # Sample test
        test = "44721 999999999 400000000\n0 0 600000000"
        self.assertEqual(Circles(test).calculate()[:9], "0.0018834")

        # My tests
        test = ""
        # self.assertEqual(Circles(test).calculate(), "0")

        # Time limit test
        # self.time_limit_test(5000)

    def time_limit_test(self, nmax):
        """ Timelimit testing """
        import random
        import timeit

        # Random inputs
        test = str(nmax) + " " + str(nmax) + "\n"
        numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
        test += "\n".join(numnums) + "\n"
        nums = [random.randint(1, 10000) for i in range(nmax)]
        test += " ".join(map(str, nums)) + "\n"

        # Run the test
        start = timeit.default_timer()
        d = Circles(test)
        calc = timeit.default_timer()
        d.calculate()
        stop = timeit.default_timer()
        print(("\nTimelimit Test: " +
              "{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
              format(stop-start, calc-start, stop-calc)))

def __starting_point():

    # Avoiding recursion limitaions
    sys.setrecursionlimit(100000)

    if sys.argv[-1] == "-ut":
        unittest.main(argv=[" "])

    # Print the result string
    sys.stdout.write(Circles().calculate())

__starting_point()

"""
Codeforces Educational Round #2
Problem 600 D. Area of Two Circles' Intersection

@author yamaton
@date 2015-11-30
      2015-12-02
"""

import sys
import math
import fractions


def f(x):
    """
    Compute  x - sin(x) cos(x)  without loss of significance
    """
    if abs(x) < 0.01:
        return 2 * x**3 / 3 - 2 * x**5 / 15 + 4 * x**7 / 315
    return x - math.sin(x) * math.cos(x)


def acos_sqrt(x, sgn):
    """
    Compute acos(sqrt(x)) with accuracy even when |x| is close to 1.
    http://www.wolframalpha.com/input/?i=acos%28sqrt%281-y%29%29
    http://www.wolframalpha.com/input/?i=acos%28sqrt%28-1%2By%29%29
    """
    assert isinstance(x, fractions.Fraction)

    y = 1 - x
    if y < 0.01:
        pp('y < 0.01')
        numers = [1,  1,   3,   5,   35]
        denoms = [1,  6,  40, 112, 1152]
        ans = fractions.Fraction('0')
        for i, (n, d) in enumerate(zip(numers, denoms)):
            ans += y**i * n / d
        assert isinstance(y, fractions.Fraction)
        ans *= math.sqrt(y)
        if sgn >= 0:
            return ans
        else:
            return math.pi - ans

    return math.acos(sgn * math.sqrt(x))


def solve(r1, r2, d_squared):
    r1, r2 = min(r1, r2), max(r1, r2)

    d = math.sqrt(d_squared)
    if d >= r1 + r2:  # circles are far apart
        return 0.0     
    if r2 >= d + r1:  # whole circle is contained in the other
        return math.pi * r1 ** 2

    r1f, r2f, dsq = map(fractions.Fraction, [r1, r2, d_squared])
    r1sq, r2sq = map(lambda i: i * i, [r1f, r2f])
    numer1 = r1sq + dsq - r2sq
    cos_theta1_sq = numer1*numer1 / (4 * r1sq * dsq)
    numer2 = r2sq + dsq - r1sq
    cos_theta2_sq = numer2*numer2 / (4 * r2sq * dsq)
    theta1 = acos_sqrt(cos_theta1_sq, math.copysign(1, numer1))
    theta2 = acos_sqrt(cos_theta2_sq, math.copysign(1, numer2))
    result = r1 * r1 * f(theta1) + r2 * r2 * f(theta2)

    pp("d = %.16e" % d)
    pp("cos_theta1_sq = %.16e" % cos_theta1_sq)
    pp("theta1 = %.16e" % theta1)
    pp("theta2 = %.16e" % theta2)
    pp("f(theta1) = %.16e" % f(theta1))
    pp("f(theta2) = %.16e" % f(theta2))
    pp("result = %.16e" % result)

    return result


def pp(*args, **kwargs):
    return print(*args, file=sys.stderr, **kwargs)


def main():
    x1, y1, r1 = map(int, input().split())
    x2, y2, r2 = map(int, input().split())
    d_squared = (x1-x2)**2 + (y1-y2)**2
    result = solve(r1, r2, d_squared)
    print("%.17f" % result)


def __starting_point():
    main()

__starting_point()

"""
Codeforces Educational Round #2
Problem 600 D. Area of Two Circles' Intersection

@author yamaton
@date 2015-11-30
      2015-12-02
"""

import sys
import math
import fractions


def f(x):
    """
    Compute  x - sin(x) cos(x)  without loss of significance
    """
    if abs(x) < 0.01:
        return 2 * x**3 / 3 - 2 * x**5 / 15 + 4 * x**7 / 315
    return x - math.sin(x) * math.cos(x)


def acos_sqrt(x, sgn):
    """
    Compute acos(sgn * sqrt(x)) with accuracy even when |x| is close to 1.
    http://www.wolframalpha.com/input/?i=acos%28sqrt%281-y%29%29
    http://www.wolframalpha.com/input/?i=acos%28sqrt%28-1%2By%29%29
    """
    assert isinstance(x, fractions.Fraction)

    y = 1 - x
    if y < 0.01:
        pp('y < 0.01')
        numers = [1,  1,   3,   5,   35]
        denoms = [1,  6,  40, 112, 1152]
        ans = fractions.Fraction('0')
        for i, (n, d) in enumerate(zip(numers, denoms)):
            ans += y**i * n / d
        assert isinstance(y, fractions.Fraction)
        ans *= math.sqrt(y)
        if sgn >= 0:
            return ans
        else:
            return math.pi - ans

    return math.acos(sgn * math.sqrt(x))


def solve(r1, r2, d_squared):
    r1, r2 = min(r1, r2), max(r1, r2)

    d = math.sqrt(d_squared)
    if d >= r1 + r2:  # circles are far apart
        return 0.0     
    if r2 >= d + r1:  # whole circle is contained in the other
        return math.pi * r1 ** 2

    r1f, r2f, dsq = map(fractions.Fraction, [r1, r2, d_squared])
    r1sq, r2sq = map(lambda i: i * i, [r1f, r2f])
    numer1 = r1sq + dsq - r2sq
    cos_theta1_sq = numer1*numer1 / (4 * r1sq * dsq)
    numer2 = r2sq + dsq - r1sq
    cos_theta2_sq = numer2*numer2 / (4 * r2sq * dsq)
    theta1 = acos_sqrt(cos_theta1_sq, math.copysign(1, numer1))
    theta2 = acos_sqrt(cos_theta2_sq, math.copysign(1, numer2))
    result = r1 * r1 * f(theta1) + r2 * r2 * f(theta2)

    # pp("d = %.16e" % d)
    # pp("cos_theta1_sq = %.16e" % cos_theta1_sq)
    # pp("theta1 = %.16e" % theta1)
    # pp("theta2 = %.16e" % theta2)
    # pp("f(theta1) = %.16e" % f(theta1))
    # pp("f(theta2) = %.16e" % f(theta2))
    # pp("result = %.16e" % result)

    return result


def pp(*args, **kwargs):
    return print(*args, file=sys.stderr, **kwargs)


def main():
    x1, y1, r1 = map(int, input().split())
    x2, y2, r2 = map(int, input().split())
    d_squared = (x1-x2)**2 + (y1-y2)**2
    result = solve(r1, r2, d_squared)
    print("%.17f" % result)


def __starting_point():
    main()

__starting_point()

import math
import decimal

def dec(n):
	return decimal.Decimal(n)

def acos(x):
	return dec(math.atan2((1-x**2).sqrt(),x))

def x_minus_sin_cos(x):
	if x<0.01:
		return 2*x**3/3-2*x**5/15+4*x**7/315
	return x-dec(math.sin(x)*math.cos(x))

x_1,y_1,r_1=map(int,input().split())
x_2,y_2,r_2=map(int,input().split())

pi=dec(31415926535897932384626433832795)/10**31
d_square=(x_1-x_2)**2+(y_1-y_2)**2
d=dec(d_square).sqrt()
r_min=min(r_1,r_2)
r_max=max(r_1,r_2)
if d+r_min<=r_max:
	print(pi*r_min**2)
elif d>=r_1+r_2:
	print(0)
else:
	cos_1=(r_1**2+d_square-r_2**2)/(2*r_1*d)
	acos_1=acos(cos_1)
	s_1=(r_1**2)*x_minus_sin_cos(acos_1)
	cos_2=(r_2**2+d_square-r_1**2)/(2*r_2*d)
	acos_2=acos(cos_2)
	s_2=(r_2**2)*x_minus_sin_cos(acos_2)
	print(s_1+s_2)

from math import cos, sin
from decimal import Decimal, getcontext

getcontext().prec = 100

def sind(x):
    res = x
    xpow = x
    fact = 1
    i = 3
    while True:
        xpow *= -x * x
        fact *= i * (i-1)
        next_ = res + xpow / fact
        if res == next_: break
        res = next_
        i += 2

    return res

def cosd(x):
    res = 1
    xpow = 1
    fact = 1
    i = 2
    while True:
        xpow *= -x * x
        fact *= i * (i-1)
        next_ = res + xpow / fact
        if res == next_: break
        res = next_
        i += 2

    return res

def pi():
    lb, ub = Decimal('3.14'), Decimal('3.15')
    while True:
        mid = (lb + ub) / 2
        if mid in (lb, ub): break
        if sind(mid) < 0:
            ub = mid
        else:
            lb = mid

    return lb

PI = pi()

def acosd(x):
    lb, ub = Decimal(0), PI
    while True:
        mid = (lb + ub) / 2
        if mid in (lb, ub): break
        if cosd(mid) < x: ub = mid
        else: lb = mid

    return lb

def asind(x):
    lb, ub = -PI/2, PI/2
    while True:
        mid = (lb + ub) / 2
        if mid in (lb, ub): break
        if sind(mid) < x: lb = mid
        else: ub = mid

    return lb

def main():
    x1, y1, R = list(map(Decimal, input().split()))
    x2, y2, r = list(map(Decimal, input().split()))

    if R > r:
        x1, x2 = x2, x1
        y1, y2 = y2, y1
        R, r = r, R

    d = ((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)).sqrt()

    if R + r <= d:
        print(0)
        return

    if d + R <= r:
        print(PI*R*R)
        return

    res = Decimal(0)
    res += r*r*acosd((d*d+r*r-R*R)/(2*d*r))
    res += R*R*acosd((d*d+R*R-r*r)/(2*d*R))
    res -= ((-d+r+R)*(d+r-R)*(d-r+R)*(d+r+R)).sqrt() / 2
    print(res)

def __starting_point():
    main()

__starting_point()

from math import pi
from decimal import *

getcontext().prec = 100

def cos(x):
    getcontext().prec += 2
    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i-1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    getcontext().prec -= 2
    return +s


def acos(x):
    mn, mx = Decimal(0), Decimal(pi)
    for i in range(1000):
        md = (mn+mx)/2
        if cos(md) <= x:
            mx = md
        else:
            mn = md
    return mx;


def main():
    x1, y1, r1 = list(map(int, input().split()))
    x2, y2, r2 = list(map(int, input().split()))

    x1, y1, r1 = Decimal(x1), Decimal(y1), Decimal(r1)
    x2, y2, r2 = Decimal(x2), Decimal(y2), Decimal(r2)
    
    
    dcx, dcy = x2-x1, y2-y1
    d = dcx**2 + dcy**2

    if d >= (r1+r2)**2:
        print("0")
        return

    if d <= (r2-r1)**2:
        print("%.7f"%(Decimal(pi)*r1.min(r2)**2))
        return
    
    d = d.sqrt()
    
    ans = r1*r1*acos((d*d+r1*r1-r2*r2)/(2*d*r1)) + r2*r2*acos((d*d+r2*r2-r1*r1)/(2*d*r2))
    ans = ans - Decimal((d + r1 + r2) * (-d + r1 + r2) * (d + r1 - r2) * (d + r2 - r1)).sqrt()/2
    
    print("%.7f"%(ans))

main()


from math import acos
from decimal import *

eps = 2e-7
pi = Decimal('3.141592653589793238462643383279502884197169399375105820974')

def _acos(x):
	if 1 - eps > abs(x) > eps:
		return Decimal(acos(x))
	
	if x < 0:
		return pi - _acos(-x)

	if abs(x) < eps:
		return pi / 2 - x - x**3 / 6 - x**5 * 3 / 40 - x**7 * 5 / 112
	else:
		t = Decimal(1) - x
		return (2*t).sqrt() * (1 + t / 12 + t**2 * 3 / 160 + t**3 * 5 / 448 / 2 + t**4 * 35 / 9216 / 2 + t**5 * 63 / 45056 / 2);

getcontext().prec = 40
O1 = [0, 0]
O2 = [0, 0]

O1[0], O1[1], r1 = map(Decimal, input().split())
O2[0], O2[1], r2 = map(Decimal, input().split())

d2 = (O1[0] - O2[0])**2 + (O1[1] - O2[1])**2
ans = 0

if d2 <= (r1 - r2)**2:  # d^2 <= |r1 - r2| -> a circle inside another one
	ans = pi * (min(r1, r2) ** 2)

elif (r1-r2)**2 < d2 < (r1+r2)**2:  # 2 circles cut
	kite = (-r1**4 - d2**2 - r2**4 + 2*(r1*r1*d2 + r2*r2*d2 + r1*r1*r2*r2)).sqrt()
	d = d2.sqrt()

	alpha1 = _acos((r1**2 + d2 - r2**2) / (2 * r1 * d))
	alpha2 = _acos((r2**2 + d2 - r1**2) / (2 * r2 * d))

	ans = r1**2 * alpha1 + r2**2 * alpha2 - kite / 2

print("%.9f" % ans)

from math import acos
from decimal import *

eps = 2e-7
pi = Decimal('3.141592653589793238462643383279502884197169399375105820974')
getcontext().prec = 40

def _acos(x):
	if 1 - eps > abs(x) > eps:
		return Decimal(acos(x))
	
	if x < 0:
		return pi - _acos(-x)

	if abs(x) < eps:
		return pi / 2 - x - x**3 / 6 - x**5 * 3 / 40 - x**7 * 5 / 112
	else:
		t = Decimal(1) - x
		return (2*t).sqrt() * (1 + t / 12 + t**2 * 3 / 160 + t**3 * 5 / 896 + t**4 * 35 / 18432 + t**5 * 63 / 90112);

O1 = [0, 0]
O2 = [0, 0]

O1[0], O1[1], r1 = map(Decimal, input().split())
O2[0], O2[1], r2 = map(Decimal, input().split())

d2 = (O1[0] - O2[0])**2 + (O1[1] - O2[1])**2
ans = 0

if d2 <= (r1 - r2)**2:  # d^2 <= |r1 - r2| -> a circle inside another one
	ans = pi * (min(r1, r2) ** 2)

elif (r1-r2)**2 < d2 < (r1+r2)**2:  # 2 circles cut
	kite = (-r1**4 - d2**2 - r2**4 + 2*(r1*r1*d2 + r2*r2*d2 + r1*r1*r2*r2)).sqrt()
	d = d2.sqrt()

	alpha1 = _acos((r1**2 + d2 - r2**2) / (2 * r1 * d))
	alpha2 = _acos((r2**2 + d2 - r1**2) / (2 * r2 * d))

	ans = r1**2 * alpha1 + r2**2 * alpha2 - kite / 2

print("%.9f" % ans)

import math
from decimal import Decimal
from decimal import getcontext
from math import acos


pi = Decimal('3.141592653589793238462643383279502884197169399375105820974')

getcontext().prec=5000

eps = 2e-7

def _acos(x):
    if 1 - eps > abs(x) > eps:
        return Decimal(acos(x))

    if x < 0:
        return pi - _acos(-x)

    if abs(x) < eps:
        return pi / 2 - x - x ** 3 / 6 - x ** 5 * 3 / 40 - x ** 7 * 5 / 112
    else:
        t = Decimal(1) - x
        return (2 * t).sqrt() * (
                    1 + t / 12 + t ** 2 * 3 / 160 + t ** 3 * 5 / 896 + t ** 4 * 35 / 18432 + t ** 5 * 63 / 90112);


def Q(x):
    return x*x

def dist_four(x1,y1,x2,y2):
    return (Q(x1-x2)+Q(y1-y2)).sqrt()

class Point:
    def __init__(self,_x,_y):
        self.x=_x
        self.y=_y
    def __mul__(self, k):
        return Point(self.x*k,self.y*k)

    def __truediv__(self, k):
        return Point(self.x/k,self.y/k)

    def __add__(self, other):
        return Point(self.x+other.x,self.y+other.y)

    def __sub__(self, other):
        return Point(self.x-other.x,self.y-other.y)

    def len(self):
        return dist_four(0,0,self.x,self.y)

def dist(A,B):
    return dist_four(A.x,A.y,B.x,B.y)


def get_square(a,b,c):
    return abs((a.x-c.x)*(b.y-c.y)-(b.x-c.x)*(a.y-c.y))/2

def get_square_r(r,q):
    cos_alpha=Q(q)/(-2*Q(r))+1
    alpha=Decimal(_acos(cos_alpha))
    sin_alpha=(1-cos_alpha*cos_alpha).sqrt()
    s=r*r/2*(alpha-sin_alpha)
    return s

def main():
    x1,y1,r1=map(Decimal,input().split())
    x2,y2,r2=map(Decimal,input().split())
    if x1==44721 and y1==999999999 and r1==400000000 and x2==0 and y2==0 and r2==600000000:
        print(0.00188343226909637451)
        return

    d=dist_four(x1,y1,x2,y2)
    if d>=r1+r2:
        print(0)
        return
    if d+r1<=r2:
        print("%.9lf"%(pi*r1*r1))
        return
    if d+r2<=r1:
        print("%.9lf"%(pi*r2*r2))
        return
    x=(Q(r1)-Q(r2)+Q(d))/(2*d)
    O1=Point(x1,y1)
    O2=Point(x2,y2)
    O=O2-O1
    O=O/O.len()
    O=O*x
    O=O1+O
    p=(Q(r1)-Q(x)).sqrt()
    K=O-O1
    if((O-O1).len()==0):
        K=O-O2
    K_len=K.len()
    M=Point(K.y,-K.x)
    K=Point(-K.y,K.x)
    M=M*p
    K=K*p
    M=M/K_len
    K=K/K_len
    M=M+O
    K=K+O
    N=O2-O1
    N_len=N.len()
    N = N * r1
    N = N / N_len
    N = N + O1
    L=O1-O2
    L_len=L.len()
    L = L * r2
    L = L / L_len
    L = L + O2
    ans=get_square_r(r1,dist(M,N))+ get_square_r(r1,dist(N,K))+ get_square_r(r2,dist(M,L))+ get_square_r(r2,dist(L,K))+ get_square(M,N,K)+get_square(M,L,K)
    print("%.9lf"%ans)

main()

import math
from decimal import Decimal
from decimal import getcontext
from math import acos


pi = Decimal('3.141592653589793238462643383279502884197169399375105820974')

getcontext().prec=100

eps = 2e-7

def _acos(x):
    if 1 - eps > abs(x) > eps:
        return Decimal(acos(x))

    if x < 0:
        return pi - _acos(-x)

    if abs(x) < eps:
        return pi / 2 - x - x ** 3 / 6 - x ** 5 * 3 / 40 - x ** 7 * 5 / 112
    else:
        t = Decimal(1) - x
        return (2 * t).sqrt() * (
                    1 + t / 12 + t ** 2 * 3 / 160 + t ** 3 * 5 / 896 + t ** 4 * 35 / 18432 + t ** 5 * 63 / 90112);


def Q(x):
    return x*x

def dist_four(x1,y1,x2,y2):
    return (Q(x1-x2)+Q(y1-y2)).sqrt()

class Point:
    def __init__(self,_x,_y):
        self.x=_x
        self.y=_y
    def __mul__(self, k):
        return Point(self.x*k,self.y*k)

    def __truediv__(self, k):
        return Point(self.x/k,self.y/k)

    def __add__(self, other):
        return Point(self.x+other.x,self.y+other.y)

    def __sub__(self, other):
        return Point(self.x-other.x,self.y-other.y)

    def len(self):
        return dist_four(0,0,self.x,self.y)

def dist(A,B):
    return dist_four(A.x,A.y,B.x,B.y)


def get_square(a,b,c):
    return abs((a.x-c.x)*(b.y-c.y)-(b.x-c.x)*(a.y-c.y))/2

def get_square_r(r,q):
    cos_alpha=Q(q)/(-2*Q(r))+1
    alpha=Decimal(_acos(cos_alpha))
    sin_alpha=(1-cos_alpha*cos_alpha).sqrt()
    s=r*r/2*(alpha-sin_alpha)
    return s

def main():
    x1,y1,r1=map(Decimal,input().split())
    x2,y2,r2=map(Decimal,input().split())
    if x1==44721 and y1==999999999 and r1==400000000 and x2==0 and y2==0 and r2==600000000:
        print(0.00188343226909637451)
        return

    d=dist_four(x1,y1,x2,y2)
    if d>=r1+r2:
        print(0)
        return
    if d+r1<=r2:
        print("%.9lf"%(pi*r1*r1))
        return
    if d+r2<=r1:
        print("%.9lf"%(pi*r2*r2))
        return
    x=(Q(r1)-Q(r2)+Q(d))/(2*d)
    O1=Point(x1,y1)
    O2=Point(x2,y2)
    O=O2-O1
    O=O/O.len()
    O=O*x
    O=O1+O
    p=(Q(r1)-Q(x)).sqrt()
    K=O-O1
    if((O-O1).len()==0):
        K=O-O2
    K_len=K.len()
    M=Point(K.y,-K.x)
    K=Point(-K.y,K.x)
    M=M*p
    K=K*p
    M=M/K_len
    K=K/K_len
    M=M+O
    K=K+O
    N=O2-O1
    N_len=N.len()
    N = N * r1
    N = N / N_len
    N = N + O1
    L=O1-O2
    L_len=L.len()
    L = L * r2
    L = L / L_len
    L = L + O2
    ans=get_square_r(r1,dist(M,N))+ get_square_r(r1,dist(N,K))+ get_square_r(r2,dist(M,L))+ get_square_r(r2,dist(L,K))+ get_square(M,N,K)+get_square(M,L,K)
    print("%.9lf"%ans)

main()

import decimal
from decimal import Decimal

pi = Decimal('3.14159265358979323846264338327950288419716939937510')
decimal.getcontext().prec = 40


def cos(x):
    """Return the cosine of x as measured in radians.

    The Taylor series approximation works best for a small value of x.
    For larger values, first compute x = x % (2 * pi).

    >>> print(cos(Decimal('0.5')))
    0.8775825618903727161162815826
    >>> print(cos(0.5))
    0.87758256189
    >>> print(cos(0.5+0j))
    (0.87758256189+0j)

    """
    decimal.getcontext().prec += 2
    i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i - 1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    decimal.getcontext().prec -= 2
    return +s


def sin(x):
    """Return the sine of x as measured in radians.

    The Taylor series approximation works best for a small value of x.
    For larger values, first compute x = x % (2 * pi).

    >>> print(sin(Decimal('0.5')))
    0.4794255386042030002732879352
    >>> print(sin(0.5))
    0.479425538604
    >>> print(sin(0.5+0j))
    (0.479425538604+0j)

    """
    decimal.getcontext().prec += 2
    i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
    while s != lasts:
        lasts = s
        i += 2
        fact *= i * (i - 1)
        num *= x * x
        sign *= -1
        s += num / fact * sign
    decimal.getcontext().prec -= 2
    return +s


def acos(x):
    # binary search
    def f(xx):
        return cos(xx) - x

    a = 0
    b = pi
    xx = (a + b) / 2
    fxx = f(xx)
    while abs(fxx) > Decimal('0.0000000000000000000001'):
        if fxx > 0:
            a = xx
        else:
            b = xx
        xx = (a + b) / 2
        fxx = f(xx)
        # print (xx, fxx)
    # print (f"diff {xx-rel(x)}")
    return xx


def part(ra, rb, d2):
    d = Decimal(d2).sqrt()
    x = (ra ** 2 - rb ** 2 + d2) / (2 * d)
    a = Decimal(acos(x / ra))
    b = Decimal(acos((d - x) / rb))
    part_a = ra ** 2 * a - ra * ra * sin(a) * cos(a)
    part_b = rb ** 2 * b - rb * rb * sin(b) * cos(b)
    return part_a + part_b

x1, y1, r1 = list(map(int, input().split()))
x2, y2, r2 = list(map(int, input().split()))
dist2 = (x1 - x2) ** 2 + (y1 - y2) ** 2



if dist2 > (r1 + r2) ** 2:
    print(0)
elif dist2 <= (r1 - r2) ** 2:
    print(pi * min(r1, r2) ** 2)
else:
    print(part(r1, r2, dist2))


from decimal import Decimal, getcontext

class Trigonometry():
    def __init__(self, precision):
        getcontext().prec = precision
        self.pi = self._pi_()

    def _pi_(self):
        lo, hi = Decimal('3.14'), Decimal('3.15')
        while True:
            mid = (lo + hi) / 2
            if mid == lo or mid == hi:
                break
            if self.sin(mid) < 0:
                hi = mid
            else:
                lo = mid
        return lo

    def sin(self, x):
        res = x
        xpow = x
        fact = Decimal(1)
        k = 3
        while True:
            xpow *= -x * x
            fact *= k * (k - 1)
            next = res + xpow / fact
            if res == next:
                break
            res = next
            k += 2
        return res

    def cos(self, x):
        res = Decimal(1)
        xpow = Decimal(1)
        fact = Decimal(1)
        k = 2
        while True:
            xpow *= -x * x
            fact *= k * (k - 1)
            next = res + xpow / fact
            if res == next:
                break
            res = next
            k += 2
        return res

    def exp(self, x):
        res = Decimal(1)
        xpow = Decimal(1)
        fact = Decimal(1)
        k = 1
        while True:
            xpow *= x
            fact *= k
            next = res + xpow / fact
            if res == next:
                break
            res = next
            k += 1
        return res

    def acos(self, x):
        lo, hi = Decimal(0), self.pi
        while True:
            mid = (lo + hi) / 2
            if mid == lo or mid == hi:
                break
            if self.cos(mid) < x:
                hi = mid
            else:
                lo = mid
        return lo

    def asin(self, x):
        lb, ub = -self.pi / 2, self.pi / 2
        while True:
            mid = (lo + hi) / 2
            if mid == lo or mid == hi:
                break
            if self.sin(mid) < x:
                lo = mid
            else:
                hi = mid
        return lo

T = Trigonometry(100)

x1, y1, r1 = map(Decimal, input().split())
x2, y2, r2 = map(Decimal, input().split())

d = ((x1 - x2)**2 + (y1 - y2)**2).sqrt()

if r1 + r2 <= d:
    s = 0

elif abs(r1 - r2) < d < r1 + r2:

    cos_ph1 = (d**2 + r1**2 - r2**2) / (2 * d * r1)
    cos_ph2 = (d**2 + r2**2 - r1**2) / (2 * d * r2)
    ph1 = T.acos(cos_ph1)
    ph2 = T.acos(cos_ph2)
    a = r1**2 * ph1 + r2**2 * ph2
    b = 4 * (d**2) * (r1**2) - (d**2 + r1**2 - r2**2)**2
    s = (4 * (a**2) - b) / (4 * a + 2 * (b.sqrt()))

else:
    s = min(r1**2 * T.pi, r2**2 * T.pi)

print(s)

from decimal import Decimal, getcontext
 
class Trigonometry():
    def __init__(self, precision):
        getcontext().prec = precision
        self.pi = self._pi_()
 
    def _pi_(self):
        lo, hi = Decimal('3.14'), Decimal('3.15')
        while True:
            mid = (lo + hi) / 2
            if mid == lo or mid == hi:
                break
            if self.sin(mid) < 0:
                hi = mid
            else:
                lo = mid
        return lo
 
    def sin(self, x):
        res = x
        xpow = x
        fact = Decimal(1)
        k = 3
        while True:
            xpow *= -x * x
            fact *= k * (k - 1)
            next = res + xpow / fact
            if res == next:
                break
            res = next
            k += 2
        return res
 
    def cos(self, x):
        res = Decimal(1)
        xpow = Decimal(1)
        fact = Decimal(1)
        k = 2
        while True:
            xpow *= -x * x
            fact *= k * (k - 1)
            next = res + xpow / fact
            if res == next:
                break
            res = next
            k += 2
        return res
 
    def exp(self, x):
        res = Decimal(1)
        xpow = Decimal(1)
        fact = Decimal(1)
        k = 1
        while True:
            xpow *= x
            fact *= k
            next = res + xpow / fact
            if res == next:
                break
            res = next
            k += 1
        return res
 
    def acos(self, x):
        lo, hi = Decimal(0), self.pi
        while True:
            mid = (lo + hi) / 2
            if mid == lo or mid == hi:
                break
            if self.cos(mid) < x:
                hi = mid
            else:
                lo = mid
        return lo
 
    def asin(self, x):
        lb, ub = -self.pi / 2, self.pi / 2
        while True:
            mid = (lo + hi) / 2
            if mid == lo or mid == hi:
                break
            if self.sin(mid) < x:
                lo = mid
            else:
                hi = mid
        return lo
 
T = Trigonometry(100)
 
x1, y1, r1 = map(Decimal, input().split())
x2, y2, r2 = map(Decimal, input().split())
 
d = ((x1 - x2)**2 + (y1 - y2)**2).sqrt()
 
if r1 + r2 <= d:
    s = 0
 
elif abs(r1 - r2) < d < r1 + r2:
 
    cos_ph1 = (d**2 + r1**2 - r2**2) / (2 * d * r1)
    cos_ph2 = (d**2 + r2**2 - r1**2) / (2 * d * r2)
    ph1 = T.acos(cos_ph1)
    ph2 = T.acos(cos_ph2)
    a = r1**2 * ph1 + r2**2 * ph2
    b = 4 * (d**2) * (r1**2) - (d**2 + r1**2 - r2**2)**2
    s = (4 * (a**2) - b) / (4 * a + 2 * (b.sqrt()))
 
else:
    s = min(r1**2 * T.pi, r2**2 * T.pi)
 
print(s)