#include <iostream>
#include <vector>

using namespace std;

using pt = pair<int64_t, int64_t>;
#define X first
#define Y second

int64_t dot(const pt& a, const pt& b) {
    return a.X * b.X + a.Y * b.Y;
}

pt operator-(const pt& a, const pt& b) {
    return pt(a.X - b.X, a.Y - b.Y);
}

int64_t cross(const pt& a, const pt& b) {
    return a.X * b.Y - b.X * a.Y;
}

int64_t len2(const pt& v) {
    return dot(v, v);
}

int64_t dist2(const pt& a, const pt& b) {
    return len2(a - b);
}

bool parallel(const pt& v1, const pt& v2) {
    return cross(v1, v2) == 0;
}

bool orthogonal(const pt& v1, const pt& v2) {
    return dot(v1, v2) == 0;
}

bool isKite(const pt& a, const pt& b, const pt& c, const pt& d) {
    return dist2(a, c) == dist2(a, d) && dist2(b, c) == dist2(b, d);
}

std::string solve() {
    vector<pt> ps;
    ps.resize(4);
    for (pt& p : ps) {
        cin >> p.X >> p.Y;
    }
    
    vector<pt> vs;
    vector<int64_t> lens;
    for (int i = 0; i < 4; ++i) {
        vs.push_back(ps[(i + 1) % 4] - ps[i]);
        lens.push_back(len2(vs.back()));
    }

    bool allOrth = true;
    for (int i = 0; i < 4; ++i) {
        if (!orthogonal(vs[i], vs[(i + 1) % 4])) {
            allOrth = false;
            break;
        }
    }

    if (lens[0] == lens[1] && lens[1] == lens[2] && lens[2] == lens[3]) {
        if (allOrth) {
           return "square"; 
        } else {
            return "rhombus";
        }
    }

    if (allOrth) {
        return "rectangle";
    }

    int parallelCount = 0;
    for (int i = 0; i <= 1; ++i) {
        if (parallel(vs[i], vs[i + 2])) {
            parallelCount += 1; 
        }
    }
    if (parallelCount == 2) {
        return "parallelogram";
    }
    if (parallelCount == 1) {
        return "trapezium";
    }

    if (isKite(ps[0], ps[2], ps[1], ps[3]) || isKite(ps[1], ps[3], ps[0], ps[2])) {
        return "kite";
    }

    return "none";
}

int main() {
    cout << solve() << endl;
    return 0;
}