#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <functional>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <istream>

#include <map>
#include <math.h>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

namespace asl
{
    
    template <typename numeric_type>
    class point
    {
    public:
        numeric_type x, y;

        point(numeric_type x = 0, numeric_type y = 0) : x(x), y(y) {}

        point<numeric_type> &operator-=(const point<numeric_type> &ri)
        {
            x -= ri.x;
            y -= ri.y;
            return *this;
        }

        friend point<numeric_type> operator-(const point<numeric_type> &a, const point<numeric_type> &b)
        {
            return point<numeric_type>(a) -= b;
        }

    };

    template <typename numeric_type>
    std::istream &operator>>(std::istream &is, point<numeric_type> &p)
    {
        return is >> p.x >> p.y;
    }

    template <typename numeric_type>
    numeric_type norm(point<numeric_type> a)
    {
        return a.x * a.x + a.y * a.y;
    }

    template <typename numeric_type, typename float_type = double>
    float_type abs(point<numeric_type> a)
    {
        return sqrtl(norm(a));
    }

    template <const int eps_exp = 9>
    int sign(double v)
    {
        const double eps = std::pow(10, -eps_exp);

        if (v < -eps)
            return -1;
        else if (v > eps)
            return +1;
        else
            return 0;
    }

} 

#include <stdint.h>

#include <experimental/optional>

namespace asl
{
    template <typename numeric_type>
    class circle
    {
    public:
        point<numeric_type> p;
        numeric_type r;
    };

    template <typename numeric_type>
    std::istream &operator>>(std::istream &is, circle<numeric_type> &c)
    {
        return is >> c.p >> c.r;
    }

    enum CircleCircleRelation
    {
        Contains = 0,
        Inscribed = 1,
        Intersect = 2,
        Circumscribed = 3,
        Separate = 4,
        Equal = 5,
    };

    template <typename numeric_type, typename float_type = double>
    CircleCircleRelation intersect_circle_circle_status(const circle<numeric_type> &c, const circle<numeric_type> &d)
    {
        float_type dist = abs(c.p - d.p);

        switch (sign(dist - c.r - d.r))
        {
        case +1:
            return CircleCircleRelation::Separate;
        case 0:
            return CircleCircleRelation::Circumscribed;
        }

        switch (sign(dist - std::abs(c.r - d.r)))
        {
        case -1:
            return CircleCircleRelation::Contains;
        case 0:
            return sign(dist) == 0 ? CircleCircleRelation::Equal : CircleCircleRelation::Inscribed;
        }

        return CircleCircleRelation::Intersect;
    }

} 

#include <random>

#define endl '\n'

using namespace std;
using namespace asl;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    circle<double> c1, c2;
    cin >> c1 >> c2;

    cout << intersect_circle_circle_status(c1, c2) << endl;

    return 0;
}





Measured memory_bytes: 3280