import std.stdio;
import std.c.stdio;
import std.range;
import std.array;
import std.functional;
import std.algorithm;
import std.conv;
import std.container;
import std.math;
import std.numeric;
import std.string;
import std.c.string;
import std.typecons;

const EPS = 1e-8;

struct Point {
    double y, x;
    Point opBinary(string op)(in Point a) const {
        static if (op == "+" || op == "-") {
            return Point(mixin("y" ~ op ~ "a.y"),
                         mixin("x" ~ op ~ "a.x"));
        }
    }
    Point opBinary(string op)(double a) const {
        static if (op == "*" || op == "/") {
            return Point(mixin("y" ~ op ~ "a"),
                         mixin("x" ~ op ~ "a"));
        }
    }
}
double norm(in Point a) {
    return sqrt(a.x * a.x + a.y * a.y);
}
double dot(in Point a, in Point b) {
    return a.x * b.x + a.y * b.y;
}
double cross(in Point a, in Point b) {
    return a.x * b.y - a.y * b.x;
}
int CCW(Point a, Point b, Point c) {
    b = b - a; c = c - a;
    if (cross(b, c) > EPS) return +1;
    if (cross(b, c) < EPS) return -1;
    if (dot(b, c) < 0) return +2;
    if (b.norm < c.norm) return -2;
    return 0;
}
 
void main() {
    Point[] segs = new Point[3];
    Point[] segt = new Point[3];
    bool input() {
        auto ps = readln.chomp.split(" ").map!(to!double).array;
        if (ps.all!((p) => p == 0)) return false;
        segs[0].x = ps[0]; segs[0].y = ps[1];
        segt[0].x = ps[2]; segt[0].y = ps[3];
        foreach (i; 1 .. 3) {
            ps = readln.chomp.split(" ").map!(to!double).array;
            segs[i].x = ps[0]; segs[i].y = ps[1];
            segt[i].x = ps[2]; segt[i].y = ps[3];
        }
        return true;
    }

    bool intersect(in Point s1, in Point t1,
            in Point s2, in Point t2) {
        return CCW(s1, t1, s2) * CCW(s1, t1, t2) <= 0 &&
            CCW(s2, t2, s1) * CCW(s2, t2, t1) <= 0;
    }

    Point iPoint(in Point s1, in Point t1,
            in Point s2, in Point t2) {
        double d = cross(t1 - s1, t2 - s2);
        return s1 + (t1 - s1) * (cross(t2 - s2, t2 - s1) / d);
    }

    void solve() {
        foreach (i; 0 .. 3) {
            if (!intersect(segs[i], segt[i], 
                        segs[(i + 1) % 3], segt[(i + 1) % 3])) {
                writeln("kyo"); return;
            }
        }
        auto vs = new Point[3];
        foreach (i; 0 .. 3) {
            vs[i] = iPoint(segs[i], segt[i], 
                        segs[(i + 1) % 3], segt[(i + 1) % 3]);
        }
        foreach (i; 0 .. 3) {
            if (vs[i] == vs[(i + 1) % 3]) {
                writeln("kyo"); return;
            }
        }
        double area = cross(vs[2] - vs[0], vs[1] - vs[0]).abs / 2;
        if (1_900_000 <= area) {
            writeln("dai-kichi");
        } else if (1_000_000 <= area) {
            writeln("chu-kichi");
        } else if (100_000 <= area) {
            writeln("kichi");
        } else if (0 < area) {
            writeln("syo-kichi");
        } else {
            writeln("kyo");
        }
    }

    while (input) solve;
}