Go: package main

import (
	"bufio"
		"os"
	"strings"
	"strconv"
	"fmt"
	"math"
)

var scanner = bufio.NewScanner(os.Stdin)

type Point struct {
	x, y float64
}
func main() {
	for scanner.Scan() {
		buf1 := strings.Split(scanner.Text(), " ")
		line1 := make([]float64, len(buf1))
		for i := range line1 {
			line1[i], _ = strconv.ParseFloat(buf1[i], 64)
		}
		if line1[0] == 0 && line1[1] == 0 &&
			line1[2] == 0 && line1[3] == 0 {
				break
		}
		scanner.Scan()
		buf2 := strings.Split(scanner.Text(), " ")
		line2 := make([]float64, len(buf2))
		for i := range line2 {
			line2[i], _ = strconv.ParseFloat(buf2[i], 64)
		}
		scanner.Scan()
		buf3 := strings.Split(scanner.Text(), " ")
		line3 := make([]float64, len(buf3))
		for i := range line2 {
			line3[i], _ = strconv.ParseFloat(buf3[i], 64)
		}
		if !intersect(line1[0], line1[1], line1[2], line1[3], line2[0], line2[1], line2[2], line2[3]) ||
			!intersect(line2[0], line2[1], line2[2], line2[3], line3[0], line3[1], line3[2], line3[3]) ||
			!intersect(line3[0], line3[1], line3[2], line3[3], line1[0], line1[1], line1[2], line1[3]) {
				fmt.Println("kyo")
		} else {
			p1 := intersection(line1[0], line1[1], line1[2], line1[3], line2[0], line2[1], line2[2], line2[3])
			p2 := intersection(line2[0], line2[1], line2[2], line2[3], line3[0], line3[1], line3[2], line3[3])
			p3 := intersection(line3[0], line3[1], line3[2], line3[3], line1[0], line1[1], line1[2], line1[3])
			area := math.Abs((p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x))/2
			if area < 0.00000001 {
				fmt.Println("kyo")
			} else if 1899999.99999999 < area {
				fmt.Println("dai-kichi")
			} else if 999999.99999999 < area {
				fmt.Println("chu-kichi")
			} else if 99999.99999999 < area {
				fmt.Println("kichi")
			} else {
				fmt.Println("syo-kichi")
			}
		}
	}
}

func cross(x1, y1, x2, y2 float64) int {
	z :=  x1 * y2 - y1 * x2
	if 0 < z {
		return 1
	} else if z < 0 {
		return -1
	} else {
		return 0
	}
}

func intersect(x1, y1, x2, y2, x3, y3, x4, y4 float64) bool {
	if 0 <= cross(x2-x1, y2-y1, x3-x1, y3-y1) *
		cross(x2-x1, y2-y1, x4-x1, y4-y1) {
			return false
	}
	if 0 <= cross(x4-x3, y4-y3, x1-x3, y1-y3) *
		cross(x4-x3, y4-y3, x2-x3, y2-y3) {
			return false
	}
	return true
}

func intersection(x1, y1, x2, y2, x3, y3, x4, y4 float64) Point {
	if x3 == x4 {
		x1, x3 = x3, x1
		y1, y3 = y3, y1
		x2, x4 = x4, x2
		y2, y4 = y4, y2
	}
	ret := Point{}
	if x1 == x2 {
		// y軸に平行な直線の場合
		c := (y4 - y3) / (x4 - x3)
		d := y3 - c * x3
		x := x1
		y := c * x + d
		ret.x, ret.y = x, y
	} else {
		a := (y2 - y1) / (x2 - x1)
		b := y1 - a * x1
		c := (y4 - y3) / (x4 - x3)
		d := y3 - c * x3
		x := (d - b) / (a - c)
		y := a * x + b
		ret.x, ret.y = x, y
	}
	return ret
}

C++: #include<cstdio>
#include<cmath>
#include<cfloat>
#include<cassert>
#include<vector>
#include<algorithm>
using namespace std;

#define EPS (1e-8)

class Point{
public:
	double x, y;
	Point ( double x = 0, double y = 0): x(x), y(y){}
	Point operator + ( Point p ){ return Point(x + p.x, y + p.y); }
	Point operator - ( Point p ){ return Point(x - p.x, y - p.y); }
	Point operator * ( double a ){ return Point(x*a, y*a); }
	double abs() { return sqrt(norm());}
	double norm() { return x*x + y*y; }
	bool operator < ( const Point &p ) const {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator == ( const Point &p ) const {
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}
};

typedef Point Vector;
typedef vector<Point> Polygon;

double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs(Vector a) {return (sqrt(norm(a)));}
double abs(Vector a, Vector b) {return (sqrt(norm(a - b)));}
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

//3点の位置関係を求める
int ccw( Point p0, Point p1, Point p2 ){
	Vector a = p1 - p0;
	Vector b = p2 - p0;
	if ( cross(a, b) > EPS ) return COUNTER_CLOCKWISE;
	if ( cross(a, b) < -EPS ) return CLOCKWISE;
	if ( dot(a, b) < -EPS ) return ONLINE_BACK;
	if ( norm(a) < norm(b) ) return ONLINE_FRONT;
	return ON_SEGMENT;
}

//A = p2 - p1, B = p4 - p3が交差するか
bool isIntersect(Point p1, Point p2, Point p3, Point p4){
	return ( ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
				ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}



//多角形の中に点があるか
bool isInside(Polygon gon, Point p ){
	for ( int i = 0; i < gon.size(); i++ ){
		if ( ccw(gon[i], gon[(i+1)%gon.size()], p) == CLOCKWISE ) return (false);
	}
	return (true);
}

//単位ベクトルを求める
Point unitVector(Point t){
	double u=abs(t);
	return Point(t.x/u , t.y/u);
}
//cosθを求める
double getcos(Point a , Point b){
	return (dot(a,b) / (abs(a)*abs(b)));
}

//sinθを求める
double getsin(Point a , Point b){
	double t=getcos(a,b);
	return sqrt(1.0-t*t);
}

//点pと直線abとの距離を求める
double pld(Point p , Point a , Point b){
	return fabs(cross(b - a,p - a))/abs(b-a);
}

//点pと線分abとの距離を求める
double psd(Point p , Point a , Point b){
	if( dot( b-a , p-a ) < EPS) return abs(p-a);
	if( dot( a-b , p-b ) < EPS) return abs(p-b);
	return fabs(cross( b-a , p-a )) / abs(b-a);
}

//線分交点計算
Point interpointS(Point a1 , Point a2 , Point b1 , Point b2){
	Point b=b2-b1;
	double d1=fabs(cross(b , a1-b1));
	double d2=fabs(cross(b , a2-b1));
	double t=d1 / (d1 + d2);
	Point a=a2-a1;
	Point v=a*t;
	return a1+v;
}

//直線交点計算
Point interpointL(Point a1 , Point a2 , Point b1 , Point b2){
	Point a=a2-a1;
	Point b=b2-b1;
	double t=cross(b , b1-a1) / cross(b , a);
	Point v=a*t;
	return a1+v;
}

//直線abと円及び球 |x-c|=rの交点を求める 　球の場合は型Point→Sに変更するだけ
void interpointLC(Point a , Point b , Point c , double r , Point ans[]){
	if(pld(c , a , b) > r + EPS) return;
	Point v=unitVector(b-a);
	double delta=dot(v,a-c)*dot(v,a-c)-abs(a-c)*abs(a-c)+r*r;
	double t=-dot(v,a-c);
	double s=sqrt(delta);
	ans[0]=a+v*(t+s);
	ans[1]=a+v*(t-s);
}

//１次変換集

//ｘ（y=k）に関する対象変換 　k=0でｘ軸による変換
Point xTranslate(Point t,double k){
	return Point(t.x , 2*k-t.y);
}

//ｙ(x=k)に関する対象変換	k=0でｙ軸による変換
Point yTranslate(Point t,double k){
	return Point(2*k-t.x , t.y);
}

//点Point kに関する対象変換		Point(0,0)で原点による変換
Point oTranslate(Point t,Point k){
	return k+(k-t);
}





//点pを中心としてr(radian)回転		p(0,0)で原点を中心として回転
Point rotate(Point t , Point p , double r){
	//double r=radians(angle);
	double ta=cos(r)*(t.x-p.x)-sin(r)*(t.y-p.y)+p.x;
	double tb=sin(r)*(t.x-p.x)+cos(r)*(t.y-p.y)+p.y;
	return Point(ta , tb);
}

//応用
//２円 |x-a|=raと|x-b|=rbの交点計算
void interpointCC(Point a , double ra , Point b , double rb , Point ans[]){
	double di=fabs(abs(a-b));
	if(di > ra+rb || di < fabs(ra-rb)) return;
	double t=(ra*ra-rb*rb+di*di)/(di+di);
	double rd=acos(t/ra);

	Point dv=unitVector(b-a);
	Point g1=rotate(dv , Point(0,0) , rd);
	Point g2=rotate(dv , Point(0,0) , -rd);
	ans[0]=a+g1*ra;
	ans[1]=a+g2*ra;
}

//法線ベクトルを求める
Point normalVector(Point p,Point a,Point b){
	Point v=unitVector(b-a);
	v = cross(v , p-a) > 0 ?  Point(v.y,(-1)*v.x) : Point((-1)*v.y , v.x);
	return v*pld(p,a,b);
}

//直線abに関する対象変換
Point fTranslate(Point t , Point a , Point b){
	return t+normalVector(t,a,b)*2;
}

//３角形の面積を求める
double area(Point a, Point b, Point c){
	return fabs(cross(c-a , b-a)*0.5);
}

//多角形の面積を求める //凸包のソート済みが前提
double polygonArea(Polygon t){
	double ans=0.0;
	for(unsigned int i=0;i<t.size();i++)
		ans+=cross(t[i] , t[(i+1)%t.size()]);
	return ans/2;
}

Polygon conhel(Polygon& ps)
{
    sort(ps.begin(), ps.end());
    int k = 0, n = static_cast<int>(ps.size());
    Polygon qs(n * 2);
    for (int i = 0; i < n; ++i) {
      while (k > 1 && cross(qs[k-1] - qs[k-2], ps[i] - qs[k-1]) < EPS)
	--k;
      qs[k++] = ps[i];
    }

    for (int i = n-2, t = k; i >= 0; --i) {
      while (k > t && cross(qs[k-1] - qs[k-2], ps[i] - qs[k-1]) < EPS)
	--k;
      qs[k++] = ps[i];
    }

    qs.resize(k-1);
    return qs;
}

int main()
{
	Point p[3], q[3], x[3];
    double S;
	
    while (1){
        for (int i = 0; i < 3; i++){
			int x1, y1, x2, y2;
            scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
			
            if (i == 0 && x1 == 0 && x2 == 0 && y1 == 0 && y2 == 0) return (0);
			
			p[i] = Point(x1, y1); q[i] = Point(x2, y2);
        }
		
		int k = 0;
		for (int i = 0; i < 3; i++){
			for (int j = i + 1; j < 3; j++){
				if (!isIntersect(p[i], q[i], p[j], q[j])){
					printf("kyo\n");
					goto next;
				}
				x[k++] = interpointS(p[i], q[i], p[j], q[j]);
			}
		}
		
		if (x[0] == x[1] || x[1] == x[2] || x[0] == x[2]){
			printf("kyo\n");
			goto next;
		}
		
		S = area(x[0], x[1], x[2]);
		
		if (S >= 1900000) printf("dai-kichi\n");
		else if (S >= 1000000) printf("chu-kichi\n");
		else if (S >= 100000) printf("kichi\n");
		else printf("syo-kichi\n");
		
		next:;
	}	
	
	return (0);
}