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++: #if 1
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <memory>
#include <string>
#include <algorithm>
#include <complex>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <bitset>
using namespace std;

#ifdef _MSC_VER
#include "_lib_msc.h"
#endif

#define ITER(c)             __typeof__((c).begin())
#define FOREACH(it, c)      for (ITER(c) it=(c).begin(); it != (c).end(); ++it)
#define RITER(c)            __typeof__((c).rbegin())
#define RFOREACH(it, c)     for (RITER(c) it=(c).rbegin(); it != (c).rend(); ++it)
#define REP(i, n)           for(int(i)=0;(i)<(n);++(i))
#define REPEAT(i, k, n)     for(int(i)=(k);(i)<((k)+(n));++(i))
#define RREP(i, n)          for(int(i)=(n)-1;(i)>=0;--(i))
#define RREPEAT(i, k, n)    for(int(i)=(k)+(n)-1;(i)>=(k);--(i))
#define FROMTO(i,f,t)       for(int(i)=(f);(i)<(t);(++i))
#define ALL(c)              (c).begin(), (c).end()
#define ESIZEOF(A)          (sizeof(A)/sizeof((A)[0]))
#define CIN_NO_SYNC         do { cin.tie(0); ios_base::sync_with_stdio(false); } while(0)
#define GETSTR(p)           fgets((p), sizeof(p), stdin)
#define CHOMP(p)            do{ char *_q = (p) + strlen(p)-1; if(*_q == '\n' || *_q == '\r') *_q = 0; } while(0)
#define FILL(m,v)           memset(m, v, sizeof(m))
#define mp                  make_pair
#define pb                  push_back
template<class _T> _T MAX(_T p1,_T p2){return (p2<p1)?p1:p2;} 
template<class _T> _T MIN(_T p1,_T p2){return (p1<p2)?p1:p2;} 
template <class _Tv> inline string join(const _Tv &v,string sep=" "){
    ostringstream s;FOREACH(it,v){if(it!=v.begin())s<<sep;s<<*it;};return s.str();
}
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef double D;
typedef complex<D> P;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
#define X real()
#define Y imag()
#define EPS (1e-9)
#define DEQ(p1,p2) (abs((p1)-(p2)) < EPS)
inline int clz(ui n){return n==0?32:__builtin_clz(n);}
inline int clz(ull n){return n==0?64:__builtin_clzll(n);}
inline int crz(ui n){return n==0?32:__builtin_ctz(n);}
inline int crz(ull n){return n==0?64:__builtin_ctzll(n);}
inline int bitc(ui n){return __builtin_popcount(n);}
inline int bitc(ull n){return __builtin_popcountll(n);} 
#ifdef _DEBUG
#include "_lib_dbg.h"
#else
#define pf(...) /* */
#define pr(...) /* */
#define prfe(...) /* */
#define prfep(...) /* */
#define dbgchk(...) /* */
#endif
#endif

const char *tbl[] = { "dai-kichi","chu-kichi","kichi","syo-kichi","kyo" };

inline D outprd(const P &a, const P &b){ return (conj(a) * b).Y; }
bool is_intersected_ls(const P &a, const P &b, const P &c, const P &d){
    return (outprd(b-a, c-a) * outprd(b-a, d-a) < EPS) && (outprd(d-c, a-c) * outprd(d-c, b-c) < EPS);
}
P intersection_l(const P &a, const P &b, const P &c, const P &d) {
    P v1 = b - a; P v2 = d - c;
    return a + v1 * outprd(v2, c-a) / outprd(v2, v1);
}
D triangle_S(P p1, P p2, P p3){
    D l1 = sqrt(norm(p1-p2));
    D l2 = sqrt(norm(p2-p3));
    D l3 = sqrt(norm(p3-p1));
    D z = (l1 + l2 + l3) / 2;
    return sqrt(z * (z - l1) * (z - l2) * (z - l3));
}

int solve(int *x1, int *y1, int *x2, int *y2){
    P p11(x1[0],y1[0]), p12(x2[0],y2[0]);
    P p21(x1[1],y1[1]), p22(x2[1],y2[1]);
    P p31(x1[2],y1[2]), p32(x2[2],y2[2]);
    if(!is_intersected_ls(p11,p12,p21,p22)) return 4;
    if(!is_intersected_ls(p21,p22,p31,p32)) return 4;
    if(!is_intersected_ls(p31,p32,p11,p12)) return 4;
    P p1 = intersection_l(p11,p12,p21,p22);
    P p2 = intersection_l(p21,p22,p31,p32);
    P p3 = intersection_l(p31,p32,p11,p12);
    D s = triangle_S(p1,p2,p3);
    if(s + EPS >= 1900000.0) return 0;
    if(s + EPS >= 1000000.0) return 1;
    if(s + EPS >= 100000.0) return 2;
    return 3;
}

int main(void){
    int x1[3],y1[3],x2[3],y2[3];
    while(1){
        cin >> x1[0] >> y1[0] >> x2[0] >> y2[0];
        if(x1[0] == 0 && y1[0] == 0 && x2[0] == 0 && y2[0] == 0) break;
        cin >> x1[1] >> y1[1] >> x2[1] >> y2[1];
        cin >> x1[2] >> y1[2] >> x2[2] >> y2[2];
        cout << tbl[solve(x1,y1,x2,y2)] << endl;
    }

    return 0;
}