#include<bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;   // 許容誤差。問題によって変える
typedef complex<double> P; // Point
//点の座標は複素数で持つ
#define X real()
#define Y imag()

namespace std{
bool operator<(const P p1, const P p2)
{
    return p1.X != p2.X ? p1.X < p2.X : p1.Y < p2.Y;
}
P operator+(const P p1, const P p2) { return P(p1.X + p2.X, p1.Y + p2.Y); }
P operator-(const P p1, const P p2) { return P(p1.X - p2.X, p1.Y - p2.Y); }
P operator*(const P p, double k) { return P(p.X * k, p.Y * k); }
P operator/(const P p, double k) { return P(p.X / k, p.Y / k); }
} // namespace std
//ここまで写経必須

//Segment/L
struct Segment{
    P p1, p2;
    Segment() {}
    Segment(P p1, P p2) : p1(p1), p2(p2) {}
};
typedef Segment L;

//Circle
struct Circle{
    P p;
    double r;
    Circle(const P &p, double r) : p(p), r(r) {}
};
typedef Circle C;

typedef vector<P> G;
//ノルム
//二点a,bを投げるとノルム(a1-b1)^2+(a2-b2)^2を返す
double norm(P &p1, P &p2){
    return (p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y);
}

//外積cross(a,b) = |a||b|sinθ=a1b2-a2b1
//二点a,bを投げると外積を返す
double cross(const P &a, const P &b){
    return (conj(a) * b).Y;
}

//内積dot(a,b) = |a||b|cosθ=a1b1+a2b2
//二点a,bを投げると内積を返す
double dot(const P &a, const P &b){
    return (conj(a) * b).X;
}

//射影
//L(又はS)と点Pを投げるとLへPを射影した座標を返す
//依存:dot,norm
P Projection(L l, P p){
    P base = l.p2 - l.p1;                        //始点
    double r = dot(p - l.p1, base) / norm(base); //線分に対する倍率の計算
    return l.p1 + base * r;
}

//鏡映
//L(又はS)と点Pを投げるとLを軸としたPの鏡像座標を返す
//依存:Projection,dot,norm
P Reflection(L l, P p){
    return p + (Projection(l, p) - p) * 2.0;
}

//位置関係判定(線分abを軸にcがどちら側にあるか)
//三点a,b,cを投げることで，a-bを軸として
//時計回りの場合:1,反時計回りの場合:-1,c-a-bの並び:2,a-b-cの並び:-2
//その他（重なってる等）:0
//依存:cross,dot,norm
int ccw(P a, P b, P c)
{
    b -= a;
    c -= a; //aからの向きを考える
    if (cross(b, c) > EPS)
        return +1; //clockwise
    else if (cross(b, c) < -EPS)
        return -1; //counter clockwise
    else if (dot(b, c) < -EPS)
        return +2; //c-a-b
    else if (norm(b) < norm(c))
        return -2; //a-b-c
    else
        return 0; //他
}

//Intersection Determination
//L,S,Pそれぞれのペアの交差判定，PPは直接比較できるのでないです
//それぞれのペアを投げる,引数の順番は関数名に記載
//交差又は含まれている場合true,そうでない場合falseを返す

//依存:cross
bool intersectLL(const L &l, const L &m)
{
    return abs(cross(l.p2 - l.p1, m.p2 - m.p1)) > EPS || // non-parallel
           abs(cross(l.p2 - l.p1, m.p1 - l.p1)) < EPS;   // same L
}
//依存:cross
bool intersectLS(const L &l, const L &s)
{
    return cross(l.p2 - l.p1, s.p1 - l.p1) * // s.p1 is left of l
               cross(l.p2 - l.p1, s.p2 - l.p1) <
           EPS; // s.p2 is right of l
}
//依存:cross
bool intersectLP(const L &l, const P &p)
{
    return abs(cross(l.p2 - p, l.p1 - p)) < EPS;
}
//依存:ccw,cross,dot,norm
bool intersectSS(const L &s, const L &t)
{
    return ccw(s.p1, s.p2, t.p1) * ccw(s.p1, s.p2, t.p2) <= 0 &&
           ccw(t.p1, t.p2, s.p1) * ccw(t.p1, t.p2, s.p2) <= 0;
}

bool intersectSP(const L &s, const P &p)
{
    return abs(s.p1 - p) + abs(s.p2 - p) - abs(s.p2 - s.p1) < EPS; // triangle inequality
}

//distance
//L,S,Pについてペアを投げるとその距離を計算
//引数の順番は関数名参照

//依存:Projection,dot,norm
double distanceLP(const L &l, const P &p)
{
    return abs(p - Projection(l, p));
}
//依存:intersectLL,cross,distanceLP,Projection,dot,norm
double distanceLL(const L &l, const L &m)
{
    return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
//依存:intersectLS,cross,distanceLP,Projection,dot,norm
double distanceLS(const L &l, const L &s)
{
    if (intersectLS(l, s))
        return 0;
    return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
//依存:intersectSP,Projection,dot,norm
double distanceSP(const L &s, const P &p)
{
    const P r = Projection(s, p);
    if (intersectSP(s, r))
        return abs(r - p);
    return min(abs(s.p1 - p), abs(s.p2 - p));
}
//依存:intersectSS,ccw,cross,dot,norm,distanceSP,intersectSP,Projection
double distanceSS(const L &s, const L &t)
{
    if (intersectSS(s, t))
        return 0;
    return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
               min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}

double distancePP(const P &p1, const P &p2)
{
    return abs(p1 - p2);
}
//二本のL(又はS)を投げると交点座標を返す
//一致している場合は一本目のp1を返します
//交わっていない場合はfalseを返します
//依存:cross
P crosspoint(const L &l, const L &m)
{
    double A = cross(l.p2 - l.p1, m.p2 - m.p1);
    double B = cross(l.p2 - l.p1, l.p2 - m.p1);
    if (abs(A) < EPS && abs(B) < EPS)
        return l.p1; // same line
    if (abs(A) < EPS)
        assert(false); // !!!PRECONDITION NOT SATISFIED!!!
    return m.p1 + B / A * (m.p2 - m.p1);
}

#define curr(P, i) P[i]
#define next(P, i) P[(i + 1) % P.size()]
#define diff(P, i) (next(P, i) - curr(P, i))
double ConvDia(const G &g)
{
    const int n = g.size();
    int is = 0, js = 0;
    for (int i = 1; i < n; i++)
    {
        if (imag(g[i]) > imag(g[is])) //点対はy座標の大きいものと小さいもののセット
            is = i;
        if (imag(g[i]) < imag(g[js]))
            js = i;
    }
    double ans = abs(g[is] - g[js]);
    int i = is, maxi = is, j = js, maxj = js;
    do
    {
        if (cross(diff(g, i), diff(g, j)) >= 0)
            j = (j + 1) % n;
        else
            i = (i + 1) % n;
        if (abs(g[i] - g[j]) > ans)
        {
            ans = abs(g[i] - g[j]);
            maxi = i;
            maxj = j;
        }
    }while (i != is or j != js);
    return ans;
}
double area(const G &g){
    double ans = 0;
    for (int i = 0; i < g.size(); i++)
        ans += cross(g[i], g[(i + 1) % g.size()]);
    return abs(ans / 2);
}
//円に関するもの置き場

//円と直線の交点
//円と直線を投げるとその交点二つを返す
//依存:Projection,diatanceLP
vector<P> crosspointCL(const C &c, const L &l)
{
    vector<P> res;
    double d = distanceLP(l, c.p); // 中心と直線の距離
    if (abs(d - c.r) < EPS)
    { // 触れている
        res.push_back(Projection(l, c.p));
        return res;
    }
    if (d > c.r)
        return res; // 離れている
    P h = Projection(l, c.p);
    P u = sqrt(c.r * c.r - d * d) * (l.p2 - l.p1) / abs(l.p2 - l.p1);
    res.push_back(h + u);
    res.push_back(h - u);
    return res;
}

//円と円の交差判定
//円を二つ投げると値を返します
//離れている:0 外接:-2 c1＞c2内接:-1 c2>c1内接:1 c1inc2:3 c2inc1:-3 交点二つ:2
int intersectCC(const C &c1, const C &c2)
{
    double d = abs(c1.p - c2.p), r1 = c1.r, r2 = c2.r;
    if (r1 + r2 < d)
        return 0; // 離れている
    if (abs(r1 + r2 - d) < EPS)
        return -2; // 外接
    if (abs(d + r1 - r2) < EPS)
        return +1; // c1 が c2 の中で内接
    if (abs(d + r2 - r1) < EPS)
        return -1; // c2 が c1 の中で内接
    if (d + r1 < r2)
        return +3; // c1 が c2 の中
    if (d + r2 < r1)
        return -3; // c2 が c1 の中
    return 2;      // 2つの交点を持つ
}

//円と円の交点
//円を二つ投げると交点が入ったvectorを返す
//交点なしor一致の場合空で返す
vector<P> crosspointCC(const C &c1, const C &c2){
    vector<P> res;
    double r1 = c1.r, r2 = c2.r, d = abs(c1.p - c2.p);
    if (abs(c1.p - c2.p) < 0)
        return res; // 中心が同じ
    int i = intersectCC(c1, c2);
    if (i == +1 || i == -1)
    { // 内接
        if (r2 < r1)
            res.push_back(c1.p + r1 / d * (c2.p - c1.p));
        else
            res.push_back(c2.p + r2 / d * (c1.p - c2.p));
        return res;
    }
    if (i == -2)
    { // 外接
        res.push_back((c1.p * c1.r + c2.p * c2.r) / (c1.r + c2.r));
        return res;
    }
    if (i == 0 || i == +3 || i == -3)
    { // 共通部分なし || 内部
        return res;
    }
    // 2つの交点を持つ
    P p = c1.p - c2.p;
    double A = -2. * p.real(), B = 2 * p.imag();
    double C = norm(c1.p) - norm(c2.p) - r1 * r1 + r2 * r2;
    L l;
    if (abs(A) < EPS)
    {
        l = L(P(0, -C / B), P(1, -C / B));
    }
    else if (abs(B) < EPS)
    {
        l = L(P(-C / A, 0), P(-C / A, 1));
    }
    else
    {
        l = L(P(0, -C / B), P(-C / A, 0));
    }
    return crosspointCL(c1,l); // Ax + By + C = 0
}
int main(){
    double x1,y1,r1,x2,y2,r2;
    cin>>x1>>y1>>r1>>x2>>y2>>r2;
    C c1 = C(P(x1, y1), r1), c2 = C(P(x2, y2), r2);
    int ans = intersectCC(c1, c2),res;
    if(ans==0)        res = 4;
    else if(ans==1 or ans==-1) res=1;
    else if(ans==2) res=2;
    else if(ans==3 or ans==-3) res=0;
    else if(ans==-2) res=3;
    cout << res << endl;
    return 0;
}


Measured memory_bytes: 3292