#include <iostream>
#include <vector>
#include <fstream>
#include <map>
#include <algorithm>
#include <set>
#include <cmath>
#include <queue>
#include <string>
#include <stack>
#include <numeric>
#include <unordered_map>
#include <functional>
#include<tuple>
#include <climits>
#include <iomanip>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long int
#define pll pair<ll,ll>
#define f(i,a,b) for(int i=a;i<b;i++)
#define f3(i,a,b,c) for(ll i=a;i<b;i+=c)
#define fr(i,a,b) for(ll i=b;i>=a;i-=1)
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define yes1 cout<<"Yes"<<endl
#define no1  cout<<"No"<<endl
#define pb push_back
#define vi vector<ll>
#define vv vector<vi>
#define mod1 998244353
#define mod 1000000007
#define ff first
#define ss second
#define get(a, n) f(i, 0LL, n) { cin >> a[i]; }
#define vp vector<pair<ll,ll>>
#define srt(a) sort(a.begin(),a.end())
#define rsrt(a) sort(a.begin(),a.end(),greater<ll>())
#define Inf LLONG_MAX 
#define out(a) for(auto &x:a){ cout<<x<<" ";}; cout<<endl;
#define pq_max priority_queue<ll,vi,less<ll>>
#define pq_min priority_queue<ll,vi,greater<ll>>
#define up(a,t) upper_bound(a.begin(),a.end(),t)
#define in_up(a,t) distance(a.begin(),up(a,t))
#define lb(a,t1) lower_bound(a.begin(),a.end(),t1)
#define in_lb(a,t1) distance(a.begin(),lb(a,t1))
#define co(t) cout << t << endl
#define mi(a) *min_element(a.begin(),a.end())
#define ma(a) *max_element(a.begin(),a.end())
#define op(v) for(auto &y:v){cout<<y.first<<" "<<y.second<<endl;}
#define vb vector<bool>
#define sum(a) accumulate(a.begin(),a.end(),0LL);
#define all(v) v.begin(),v.end()
#define  cod cout<<endl
#define matrix(a, n, m) \
    for (ll i = 0; i < n; i++) { \
        for (ll j = 0; j < m; j++) { \
            cout << a[i][j] << " "; \
        } \
        cout << endl; \
    }
ll gcd(ll a, ll b) {
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
vi fs(ll n) {
    vi fac;
    for(ll i=1;i*i<=n;i++){
      if(n%i==0){
        ll f1=i;
        ll f2=n/i;
        fac.pb(i);
        if(f1!=f2) fac.pb(f2);
      }
    }
    srt(fac);
    return fac;
}
string bin(ll n, ll len) {
    string s;
    for (int i = 0; i < len; i++) {
        if (n%2==1) s += '1';
        else s += '0';
        n/=2;
    }
    reverse(s.begin(), s.end());
    return s;
}

bool isPrime(ll n) {
    if (n <= 1) {
        return false;
    }
    if (n <= 3) {
        return true;
    }
    if (n % 2 == 0 || n % 3 == 0) {
        return false;
    }
    for (ll i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}
bool cp(const pair<ll,ll>& a, const pair<ll,ll>& b) {
    return a.second < b.second;
}

ll max_sub(ll n, vi a) {
    ll ms = 0, cs = 0;
    f(i, 0, n) {
        cs += a[i];
        if(cs > ms) ms = cs;
        if(cs < 0) cs = 0;
    }
    return ms;
}

vb seive(ll n) {
    vb p(n + 1, true);
    for(ll i = 2; i * i <= n; i++) {
        if(p[i] == true) {
            for(ll j = i * i; j <= n; j += i) p[j] = false;
        }
    }
    return p;
}

vi sei(ll n) {
    vi spf(n + 1);
    f(i, 1, n + 1) { spf[i] = i; }
    for(ll i = 2; i * i <= n; i++) {
        if(spf[i] == i) {
            for(ll j = i * i; j <= n; j += i) {
                if(spf[j] == j) {
                    spf[j] = i;
                }
            }
        }
    }
    return spf;
}

ll expo(ll base, ll exp1) {
    ll res = 1;
    while (exp1 > 0) {
        if (exp1 % 2 == 1) res = (res * base);
        base = (base * base) ;
        exp1 /= 2;
    }
    return res;
}
ll expo_m(ll base, ll exp1, ll z) {
    ll res = 1;
    while (exp1 > 0) {
        if (exp1 % 2 == 1) res = (res * base) % z;
        base = (base * base) % z;
        exp1 /= 2;
    }
    return res;
}
vector<ll>fac;
/*void fact(ll n) {
    fac.assign(n + 1, 1);
    for (ll i = 1; i <= n; i++) {
        fac[i] = (fac[i - 1] * i) % mod;
    }
}
 
ll comb(ll n, ll r) {
    if (r > n || r < 0) return 0;
    return fac[n] * expo(fac[r], mod - 2, mod) % mod * expo(fac[n - r], mod - 2, mod) % mod;
}*/
 
//  __builtin_ctz(v) gives trailing zeros of number in binary representation.
// int __builtin_popcount(unsigned int x) for counting number of 1's in binary representation;
// dont use unordered_map they can set up test case to make it o(n**2)
// dont use map if limit is low(up to 1e6)
/*struct FenwickTree {
    vector<ll> bit;
    ll N;
    FenwickTree(ll size) : N(size), bit(size + 1, 0) {}
    void update(ll idx, ll value) {
        while (idx <= N) {
            bit[idx] += value;
            idx += idx & -idx;
        }
    }
    ll tree_sum(ll idx) const {
        ll res = 0;
        while (idx > 0) {
            res += bit[idx];
            idx -= idx & -idx;
        }
        return res;
    }
    ll l_r(ll l, ll r) const {
        return tree_sum(r) - tree_sum(l - 1);
    }
    ll lower(ll x){
      ll prev=0LL,pos=0LL;
      for(ll i=20;i>=0;i--){
        if(pos + (1LL << i)<N and prev+bit[pos+(1LL<<i)]<x){
          prev+=bit[pos+(1LL<<i)];
          pos+=(1LL<<i);
        }
      }
      return pos+1LL;
    }
};*/
/*class SegmentTree {
    struct Node {
      
    };

    vector<Node> seg;
    vi a;
    ll n;
    void build(ll node, ll start, ll end) {
        if (start == end) {
            seg[node] = {a[start] + start, a[start] + start, a[start] - start, a[start] - start, 0};
        } else {
            ll mid = (start + end) / 2;
            build(2 * node + 1, start, mid);
            build(2 * node + 2, mid + 1, end);
            mergeNodes(seg[node], seg[2 * node + 1], seg[2 * node + 2]);
        }
    }

    void mergeNodes(Node &parent, const Node &left, const Node &right) {
     
    }

    Node query(ll node, ll start, ll end, ll l, ll r) {
        if (r < start || l > end) return {-LLONG_MAX, LLONG_MAX, -LLONG_MAX, LLONG_MAX, 0};
        if (l <= start && r >= end) return seg[node];
        ll mid = (start + end) / 2;
        Node left = query(2 * node + 1, start, mid, l, r);
        Node right = query(2 * node + 2, mid + 1, end, l, r);
        Node res;
        mergeNodes(res, left, right);
        return res;
    }
    void update(ll node, ll start, ll end, ll idx, ll value) {
        if (start == end) {
            a[idx] = value;
           
        } else {
            ll mid = (start + end) / 2;
            if (idx <= mid) {
                update(2 * node + 1, start, mid, idx, value);
            } else {
                update(2 * node + 2, mid + 1, end, idx, value);
            }
            mergeNodes(seg[node], seg[2 * node + 1], seg[2 * node + 2]);
        }
    }

public:
    SegmentTree(const vi &input_a) {
        n = input_a.size();
        a = input_a;
        seg.resize(4 * n);
        build(0, 0, n - 1);
    }

    ll query(ll l, ll r) {
        Node res = query(0, 0, n - 1, l, r);
        return res.ans;
    }

    void update(ll idx, ll value) {
        update(0, 0, n - 1, idx, value);
    }
};*/
void solve() {
    int A, B, C;
    cin >> A >> B >> C;

    // Check if a triangle can be formed
    if (A + B <= C || A + C <= B || B + C <= A) {
        cout << "Not a triangle\n";
        return;
    }

    // Determine the type of triangle
    if (A == B && B == C) {
        cout << "Equilateral\n";
    } else if (A == B || B == C || A == C) {
        cout << "Isosceles\n";
    } else {
        cout << "Scalene\n";
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
   /*#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif*/
    // fact(3e5+1)
    ll t = 1LL;
    // cin >> t;
    while (t--) {
        solve();
    }
    #ifndef ONLINE_JUDGE
    cout << "run_time " << (((float)(clock())) / CLOCKS_PER_SEC)*1000 << " ms";
    #endif
    return 0;
}