#include <iostream> 
#include <sstream> 
#include <iomanip> 
#include <algorithm> 
#include <cmath> 
#include <string> 
#include <vector> 
#include <list> 
#include <queue> 
#include <stack> 
#include <set> 
#include <map> 
#include <bitset> 
#include <numeric> 
#include <climits> 
#include <cfloat> 
using namespace std;

const double EPS = 1.0e-10;

class Point
{
public:
    double y, x;
    Point(){
        y = x = 0.0;
    }
    Point(double y0, double x0){
        y = y0;
        x = x0;
    }
    Point operator+(const Point& p) const{
        return Point(y + p.y, x + p.x);
    }
    Point operator-(const Point& p) const{
        return Point(y - p.y, x - p.x);
    }
    Point operator*(double a) const{
        return Point(y * a, x * a);
    }
    Point operator/(double a) const{
        return Point(y / a, x / a);
    }
    double dot(const Point& p) const{
        return y * p.y + x * p.x; // |a|*|b|*cosÆ
    }
    double cross(const Point& p) const{
        return x * p.y - y * p.x; // |a|*|b|*sinÆ
    }
};

class Line
{
public:
    double a, b, c; // a*x + b*y + c = 0
    Line(){
        a = c = 0.0;
        b = 1.0;
    }
    Line(double a0, double b0, double c0){
        a = a0;
        b = b0;
        c = c0;
    }
    Line(const Point& p1, const Point& p2){ // 2_ðÔ¼ü
        double dy = p2.y - p1.y;
        double dx = p2.x - p1.x;
        if(abs(dy / dx) < EPS){
            a = 0.0;
            b = 1.0;
            c = -p1.y;
        }else if(abs(dx / dy) < EPS){
            a = 1.0;
            b = 0.0;
            c = -p1.x;
        }else{
            a = - dy / dx;
            b = 1.0;
            c = dy / dx * p1.x - p1.y;
        }
    }
};

bool segmentsCollide(const Point& a1, const Point& a2, const Point& b1, const Point& b2)
{
    if(min(a1.x, a2.x) > max(b1.x, b2.x) + EPS || min(b1.x, b2.x) > max(a1.x, a2.x) + EPS || min(a1.y, a2.y) > max(b1.y, b2.y) + EPS || min(b1.y, b2.y) > max(a1.y, a2.y) + EPS)
        return false;

    return ((a2-a1).cross(b1-a1) * (a2-a1).cross(b2-a1) < -EPS) && ((b2-b1).cross(a1-b1) * (b2-b1).cross(a2-b1) < -EPS);
}

bool linesIntersection(const Line& l1, const Line& l2, Point& intersection)
{
    double s = l1.a*l2.b - l2.a*l1.b;
    if(abs(s) < EPS)
        return false;

    intersection = Point(l2.a*l1.c - l1.a*l2.c, l1.b*l2.c - l2.b*l1.c) / s;
    return true;
}

double polygonArea(const vector<Point>& p)
{
    int n = p.size();
    double ret = 0.0;
    for(int i=0; i<n; ++i)
        ret += p[i].cross(p[(i+1)%n]);
    return abs(ret) / 2.0;
}

int main()
{
    for(;;){
        vector<Point> p(6);
        for(int i=0; i<6; ++i)
            cin >> p[i].x >> p[i].y;
        if(p[0].x == 0 && p[0].y == 0 && p[1].x == 0 && p[1].y == 0)
            return 0;

        bool kyo = false;
        for(int i=0; i<3; ++i){
            if(!segmentsCollide(p[i*2], p[i*2+1], p[(i+1)*2%6], p[((i+1)*2+1)%6]))
                kyo = true;
        }
        if(kyo){
            cout << "kyo" << endl;
            continue;
        }

        vector<Line> line(3);
        for(int i=0; i<3; ++i)
            line[i] = Line(p[i*2], p[i*2+1]);
        vector<Point> p1(3);
        for(int i=0; i<3; ++i)
            linesIntersection(line[i], line[(i+1)%3], p1[i]);

        double area = polygonArea(p1);
        if(area > 1900000 - EPS)
            cout << "dai-kichi" << endl;
        else if(area > 1000000 - EPS)
            cout << "chu-kichi" << endl;
        else if(area > 100000 - EPS)
            cout << "kichi" << endl;
        else if(area > EPS)
            cout << "syo-kichi" << endl;
        else
            cout << "kyo" << endl;
    }
}

Measured memory_bytes: 0