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 <bits/stdc++.h>

using namespace std;

class Point {
public:
	double x, y;
};

class LineInfo {
public:
	Point p1, p2;

	LineInfo() {
		p1.x = p1.y = p2.x = p2.y = 1001;
	}
};

LineInfo LineData[3];
Point CrossPoint[3];
double Result;


double Cross_Prouct(Point A, Point B, Point C) {					//ABxAC
	return (B.x - A.x)*(C.y - A.y) - (B.y - A.y)*(C.x - A.x);
}

void getCrossPoint(int index, Point s1p1, Point s1p2, Point s2p1, Point s2p2) {

	double d1 = fabs(Cross_Prouct(s2p1, s2p2, s1p1));
	double d2 = fabs(Cross_Prouct(s2p1, s2p2, s1p2));
	double t = d1 / (d1 + d2);
	CrossPoint[index].x = s1p1.x + (s1p2.x - s1p1.x)*t;
	CrossPoint[index].y = s1p1.y + (s1p2.y - s1p1.y)*t;
}

bool isIntersection(Point A, Point B, Point C, Point D) {
	if (max(A.x, B.x) < min(C.x, D.x)) {
		return false;
	}
	if (max(C.x, D.x) < min(A.x, B.x)) {
		return false;
	}
	if (max(A.y, B.y) < min(C.y, D.y)) {
		return false;
	}
	if (max(C.y, D.y) < min(A.y, B.y)) {
		return false;
	}
	if (Cross_Prouct(A, B, C)*Cross_Prouct(A, B, D) <= 0 &&
		Cross_Prouct(C, D, A)*Cross_Prouct(C, D, B) <= 0) {
		return true;
	}
	/*if (min(A.x, B.x) <= max(C.x, D.x) &&
		min(C.x, D.x) <= max(A.x, B.x) &&
		min(A.y, B.y) <= max(C.y, D.y) &&
		min(C.y, D.y) <= max(A.y, B.y) &&
		Cross_Prouct(A, B, C)*Cross_Prouct(A, B, D) <= 0 &&
		Cross_Prouct(C, D, A)*Cross_Prouct(C, D, B) <= 0) {
		return true;
	}*/
	return false;
}

void solve() {

	if (!isIntersection(LineData[0].p1, LineData[0].p2, LineData[1].p1, LineData[1].p2)) {
		//三角形なし
		Result = 0.0;
		return;
	}
	if (!isIntersection(LineData[1].p1, LineData[1].p2, LineData[2].p1, LineData[2].p2)) {
		//三角形なし
		Result = 0.0;
		return;
	}
	if (!isIntersection(LineData[2].p1, LineData[2].p2, LineData[0].p1, LineData[0].p2)) {
		//三角形なし
		Result = 0.0;
		return;
	}

	for (int i = 0; i < 3; i++) {
		getCrossPoint(i, LineData[i].p1, LineData[i].p2, LineData[(i + 1) % 3].p1, LineData[(i + 1) % 3].p2);
	}

	Result = fabs(Cross_Prouct(CrossPoint[0], CrossPoint[1], CrossPoint[2])) / 2.0;
	//cout << Result << endl;
}

int main() {
	int x1, y1, x2, y2;

	while (1) {
		for (int i = 0; i < 3; i++) {
			cin >> x1 >> y1 >> x2 >> y2;
			if (i == 0 && x1 == 0 && y1 == 0 && x2 == 0 && y2 == 0) {
				return 0;
			}
			LineData[i].p1.x = x1;
			LineData[i].p1.y = y1;
			LineData[i].p2.x = x2;
			LineData[i].p2.y = y2;
		}
		/*for (int i = 0; i < 3; i++) {
			cout << LineData[i].p1.x << " " << LineData[i].p1.y << " " << LineData[i].p2.x << " " << LineData[i].p2.y << endl;
		}*/
		solve();
		if (Result >= 1900000) {
			cout << "dai-kichi" << endl;
		}
		else if (Result >= 1000000) {
			cout << "chu-kichi" << endl;
		}
		else if (Result >= 100000) {
			cout << "kichi" << endl;
		}
		else if (Result > 0) {
			cout << "syo-kichi" << endl;
		}
		else {
			cout << "kyo" << endl;
		}
	}

	return 0;
}