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>

#define EPS (1e-9)

using namespace std;

bool eq(double a, double b)
{
	return (fabs(b - a) <= EPS);
}

bool getP(int x1, int y1, int x2, int y2, int p1, int q1, int p2, int q2, double *r1, double *r2)
{
	int D = (x2 - x1) * (q2 - q1) - (y2 - y1) * (p2 - p1);
	if (D == 0) return (false);
	
	double r, s;
	
	r = ((q2 - q1) * (p1 - x1) - (p2 - p1) * (q1 - y1)) / (double)D;
	s = ((y2 - y1) * (p1 - x1) - (y2 - y1) * (q1 - y1)) / (double)D;
	//printf("%lf %lf\n", r, s);
	if (0 <= r + EPS && r - EPS <= 1 &&
		0 <= s + EPS && s - EPS <= 1){
		*r1 = x1 + r * (x2 - x1);
		*r2 = y1 + r * (y2 - y1);
		return (true);
	}
	
	return (false);
}

int main()
{
	int x1[3], y1[3], x2[3], y2[3];
	double x3[3], y3[3];
	
	while (1){
		for (int i = 0; i < 3; i++){
			scanf("%d %d %d %d", x1 + i, y1 + i, x2 + i, y2 + i);
			if (x1[i] == 0 && x2[i] == 0 && y1[i] == 0 && y2[i] == 0) return (0);
		}
		
		int k = 0;
		for (int i = 0; i < 3; i++){
			for (int j = i + 1; j < 3; j++){
				if (!getP(x1[i], y1[i], x2[i], y2[i],
						  x1[j], y1[j], x2[j], y2[j],
						  &x3[k], &y3[k])){
						  printf("kyo\n");
						  goto ng;
				}
				k++;
			}
		}
		
		for (int i = 0; i < 3; i++) for (int j = i + 1; j < 3; j++) if (eq(x3[i], x3[j]) && eq(y3[i], y3[j])){
			printf("kyo\n"); goto ng;
		}
		x3[0] -= x3[2]; x3[1] -= x3[2];
		y3[0] -= y3[2]; y3[1] -= y3[2];
		
		double S;
		
		S = 0.5 * fabs(x3[0] * y3[1] - y3[0] * x3[1]);
		
		if (S + EPS >= 1900000) printf("dai-kichi\n");
		else if (S + EPS >= 1000000) printf("chu-kichi\n");
		else if (S + EPS >= 100000) printf("kichi\n");
		else if (S + EPS > 0) printf("syo-kichi\n");
		else printf("kyo\n");
		
		ng:;
	}
	
	return (0);
}

C++: #include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <vector>
#include <queue>
#include <bitset>
#include <string>
using namespace std;
 
#define rep(i,n) for(int i=0; i<n; i++)
#define repa(i,s,e) for(int i=s; i<=e; i++)
#define repd(i,s,e) for(int i=s; i>=e; i--)
#define PB(a) push_back(a)
#define MP(i,s) make_pair(i,s)
 
typedef long long ll;

// geometry library start

const double EPS = 1.0e-10;

class P {
public:
	double x, y;
	P() {}
	P(int x_, int y_) : x(x_), y(y_) {}
	P(double x_, double y_) : x(x_), y(y_) {}
	P(const P& p) : x(p.x), y(p.y) {}
	P operator+(const P& p) const { return P(x+p.x, y+p.y); } 
	P operator-(const P& p) const { return P(x-p.x, y-p.y); }
	P operator-() const { return P(-x, -y); }
	P operator*(double s) const { return P(x*s, y*s); }
	P operator/(double s) const { return P(x/s, y/s); }
	P& operator=(const P& p) { x=p.x; y=p.y; return (*this); }
	double dot(const P& p) const { return x*p.x + y*p.y; }
	double det(const P& p) const { return x*p.y - y*p.x; }
	double norm() const { return sqrt(x*x + y*y); }
	double norm2() const { return x*x + y*y; }
	P proj(const P& p) const { double k=det(p)/norm2(); return P(x*k, y*k); }
};

double tri(P a, P b, P c) { return (b - a).det(c - a); }
int sign(double r) { return r < -EPS ? -1 : r > EPS ? 1 : 0; }

class L {
public:
	P s, t;
	L() {}
	L(P s_, P t_) : s(s_), t(t_) {}
	L(const L& l) : s(l.s), t(l.t) {}
	L& operator=(const L& l) { s=l.s; t=l.t; return (*this); }
	double length() { return (s - t).norm(); }
	P vec() const { return t - s; }
	P proj(const P& p) { return s + vec().proj(p - s); }
	int iLL(const L& l) const {
		if(sign(vec().det(l.vec()))) return 1;
		if(sign(vec().det(l.s - s))) return 0;
		return -1;
	}
	bool iLS(const L& l) const { return sign(tri(s, t, l.s)) * sign(tri(s, t, l.t)) <= 0; } 
	bool iSS(const L& l) const { return iLS(l) && l.iLS(*this); }
	P pLL(const L& l) const { return s + vec() * (l.s - s).det(l.vec()) / t.det(l.vec()); }
	double dLP(const P& p) const { return abs(tri(s, t, p)) / vec().norm(); }
	double dSP(const P& p) const {
		if(sign(vec().dot(p - s)) <= 0) return (p - s).norm();
		if(sign(vec().dot(p - t)) >= 0) return (p - t).norm();
		return dLP(p);
	}
};

class C {
public:
	P p;
	double r;
	C() {}
	C(P p_, double r_) : p(p_), r(r_) {}
	C(const C& c) : p(c.p), r(c.r) {}
	C& operator=(const C& c) { p=c.p; r=c.r; return (*this); }
};

// geometry library end
int x1, z1, x2, z2;
L E[3];
P T[3];

int area[4] = { 1900000, 1000000, 100000, 0 };
string fort[4] = { "dai-kichi", "chu-kichi", "kichi", "syo-kichi" };

void solve() {
	rep(i,3) {
		if(!E[i].iSS(E[(i+1)%3])) {
			printf("kyo\n");
			return;
		}
		T[i] = E[i].pLL(E[(i+1)%3]);
	}
	
	double S = abs((T[1] - T[0]).det(T[2] - T[1])) * 0.5;
	rep(i,4) {
		if(S >= area[i]) {
			cout << fort[i] << endl;
			return;
		}
	}	
}

int main() {
	for(;;) {
		scanf("%d%d%d%d", &x1, &z1, &x2, &z2);
		if(x1==0 && z1==0 && x2==0 && z2==0) break;
		E[0] = L(P(x1, z1), P(x2, z2));

		scanf("%d%d%d%d", &x1, &z1, &x2, &z2);
		E[1] = L(P(x1, z1), P(x2, z2));

		scanf("%d%d%d%d", &x1, &z1, &x2, &z2);
		E[2] = L(P(x1, z1), P(x2, z2));

		solve();
	}
}