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 <iostream>
#include <cmath>
using namespace std;

const double EPS = 1e-8;

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

template<class T> class Vector2
{
public:
	int crossProduct( const Vector2& v )
	{
		return x * v.y - v.x * y;
	}

	T x, y;
};

int main()
{
	int x1, y1, x2, y2;
	while( cin >> x1 >> y1 >> x2 >> y2 && ( x1 || y1 || x2 || y2 ) ){
		Vector2<int> p[ 3 ][ 2 ];
		Vector2<int> v[ 3 ];
		p[ 0 ][ 0 ].x = x1;
		p[ 0 ][ 0 ].y = y1;
		p[ 0 ][ 1 ].x = x2;
		p[ 0 ][ 1 ].y = y2;
		v[ 0 ].x = x2 - x1;
		v[ 0 ].y = y2 - y1;
		for( int i = 1; i < 3; ++i ){
			cin >> x1 >> y1 >> x2 >> y2;
			p[ i ][ 0 ].x = x1;
			p[ i ][ 0 ].y = y1;
			p[ i ][ 1 ].x = x2;
			p[ i ][ 1 ].y = y2;
			v[ i ].x = x2 - x1;
			v[ i ].y = y2 - y1;
		}

		int result = 0;
		if( v[ 0 ].crossProduct( v[ 1 ] ) * v[ 1 ].crossProduct( v[ 2 ] ) * v[ 2 ].crossProduct( v[ 0 ] ) == 0 ){
			result = 4;
		}else{
			Vector2<double> e[ 3 ];
			for( int i = 0; i < 3; ++i ){
				int a = i;
				int b = ( i + 1 ) % 3;
				int ax = p[ a ][ 0 ].x;
				int ay = p[ a ][ 0 ].y;
				int cx = p[ b ][ 0 ].x;
				int cy = p[ b ][ 0 ].y;
				int abx = v[ a ].x;
				int aby = v[ a ].y;
				int cdx = v[ b ].x;
				int cdy = v[ b ].y;
				double s = static_cast<double>( cdy * ( cx - ax ) - cdx * ( cy - ay ) )
					/ static_cast<double>( abx * cdy - cdx * aby );
				double t = static_cast<double>( aby * ( cx - ax ) - abx * ( cy - ay ) )
					/ static_cast<double>( abx * cdy - cdx * aby );
				if( s + EPS > 1.0 || s - EPS < 0.0 ){
					result = 4;
					break;
				}
				if( t + EPS > 1.0 || t - EPS < 0.0 ){
					result = 4;
					break;
				}
				e[ i ].x = p[ i ][ 0 ].x + s * v[ i ].x;
				e[ i ].y = p[ i ][ 0 ].y + s * v[ i ].y;
			}
			if( result != 4 ){
				Vector2<double> tmp;
				tmp.x = e[ 0 ].x;
				tmp.y = e[ 0 ].y;
				for( int i = 0; i < 3; ++i ){
					e[ i ].x -= tmp.x;
					e[ i ].y -= tmp.y;
				}
				double sq = fabs( e[ 1 ].x * e[ 2 ].y - e[ 2 ].x * e[ 1 ].y ) / 2;
				if( sq < EPS ){
					result = 4;
				}else if( sq < 100000 ){
					result = 3;
				}else if( sq < 1000000 ){
					result = 2;
				}else if( sq < 1900000 ){
					result = 1;
				}else{
					result = 0;
				}
			}
		}
		cout << fortune[ result ] << endl;
	}

	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;

const double EPS = 1e-10;
const double INF = 1e12;
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()

typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
    L(const P& a, const P& b){ at(0)=a; at(1)=b; }
    L(){}
};
namespace std{
    bool operator < (const P& a, const P& b){
        return (a.X!=b.X) ? a.X<b.X : a.Y<b.Y;
    }
    bool operator == (const P& a, const P& b){
        return abs(a-b) < EPS;
    }
}

double dot(P a, P b){
    return (conj(a)*b).X;
}
double cross(P a, P b){
    return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
    b -= a;
    c -= a;
    if(cross(b,c) > EPS) return +1; //ccw
    if(cross(b,c) < -EPS) return -1; //cw
    if(dot(b,c) < -EPS) return +2; //c-a-b
    if(abs(c)-abs(b) > EPS) return -2; //a-b-c
    return 0; //a-c-b
}

bool intersectSS(const L& a, const L& b){
    return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
        ( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
P crosspointLL(const L &l, const L &m) {
  double A = cross(l[1]-l[0], m[1]-m[0]);
  double B = cross(l[1]-l[0], l[1]-m[0]);
  return m[0] + B/A *(m[1]-m[0]);
}
bool isParallel(const P &a, const P &b){
    return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
    return isParallel(a[1]-a[0], b[1]-b[0]);
}
double getarea(const VP &poly){
    double ret = 0;
    for (int i=0; i<(int)poly.size(); i++){ 
        ret += cross(poly[i], poly[(i+1)%poly.size()]);
    }
    return ret*0.5;
}

int main(){
	while(1){
		int x1,y1,x2,y2;
		cin >> x1 >> y1 >> x2 >> y2;
		if(x1==0 && y1==0 && x2==0 && y2==0) break;
		vector<L> line(3);
		for(int i=0; i<3; i++){
			if(i != 0) cin >> x1 >> y1 >> x2 >> y2;
			line[i] = L(P(x1,y1), P(x2,y2));
		}
		VP v;
		for(int i=0; i<3; i++){
			if(!isParallel(line[i], line[(i+1)%3]) && intersectSS(line[i], line[(i+1)%3])){
				v.push_back(crosspointLL(line[i], line[(i+1)%3]));
			}
		}
		sort(v.begin(), v.end());
		v.erase(unique(v.begin(), v.end()), v.end());
		if((int)v.size() != 3){
			cout << "kyo" << endl;
		}else{
			if(ccw(v[0], v[1], v[2]) == -1) swap(v[1], v[2]);
			double s = getarea(v);
			if(s >= 1900000){
				cout << "dai-kichi" << endl;
			}else if(s >= 1000000){
				cout << "chu-kichi" << endl;
			}else if(s >= 100000){
				cout << "kichi" << endl;
			}else{
				cout << "syo-kichi" << endl;
			}
		}
	}
	return 0;
}