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 <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <iostream>
#include <sstream>
#include <climits>
#include <cfloat>
#include <complex>

using namespace std;

typedef complex<double> Point;

const double Eps = 1e-6;

double dot(const Point& a, const Point& b)
{
	return a.real()*b.real() + a.imag()*b.imag();
}
double cross(const Point& a, const Point& b)
{
	return a.real()*b.imag() - a.imag()*b.real();
}
double distance_line_point(const Point& point, const Point& a, const Point& b)
{
	return abs(cross(a-b, point-b) / (a-b));
}
double distance_linesegment_point(const Point& point, const Point& a, const Point& b)
{
	if (dot(b-a, point-a) < 0)
		return abs(a-point);
	else if (dot(a-b, point-b) < 0)
		return abs(b-point);
	else
		return distance_line_point(point, a, b);
}
bool is_in_triangle(const Point& point, const Point* triangle)
{
	double t[3];
	for (int i = 0; i < 3; ++i)
		t[i] = cross(triangle[(i+1)%3] - triangle[i], point - triangle[i]);
	return t[0] >= 0 && t[1] >= 0 && t[2] >= 0
		|| t[0] <= 0 && t[1] <= 0 && t[2] <= 0;
}
bool is_in_triangle(const Point& point, const Point& a, const Point& b, const Point& c)
{
	Point t[3] = { a, b, c };
	return is_in_triangle(point, t);
}
bool is_circle_in_triangle(const Point& center, double radius, const Point* triangle)
{
	if (!is_in_triangle(center, triangle))
		return false;
	for (int i = 0; i < 3; ++i)
		if (distance_line_point(center, triangle[i], triangle[(i+1)%3]) < radius - Eps)
			return false;
	return true;
}
bool is_triangle_in_circle(const Point* triangle, const Point& center, double radius)
{
	for (int i = 0; i < 3; ++i)
		if (abs(triangle[i]-center) > radius + Eps)
			return false;
	return true;
}
bool is_interect_linesegments(const Point& a1, const Point& a2, const Point& b1, const Point& b2)
{
	return cross(a2-a1, b1-a1)*cross(a2-a1, b2-a2) < Eps
		&& cross(b2-b1, a1-b1)*cross(b2-b1, a2-b1) < Eps;
}
bool is_interect_triangle_circle(const Point* triangle, const Point& center, double radius)
{
	for (int i = 0; i < 3; ++i)
		if (distance_linesegment_point(center, triangle[i], triangle[(i+1)%3]) < radius + Eps)
			return true;
	return false;
}
Point intersectin_point(const Point& a1, const Point& a2, const Point& b1, const Point& b2)
{
	double d1 = distance_linesegment_point(a1, b1, b2);
	double d2 = distance_linesegment_point(a2, b1, b2);
	double prop = d1 / (d1 + d2);
	return a1 + (a2 - a1) * prop;
}
double area_polygon(const Point* points, int n)
{
	double s = 0;
	for (int i = 0; i < n; ++i)
		s += cross(points[i], points[(i+1) % n]);
	return abs(s / 2);
}
double area_triangle(const Point* points)
{
	return area_polygon(points, 3);
}
double area_triangle(const Point& a, const Point& b, const Point& c)
{
	Point t[] = { a, b, c };
	return area_triangle(t);
}

int main()
{
	double thresh[] = { 1900000, 1000000, 100000, 2*Eps, -1e10 };
	char* kuji[] = { "dai-kichi", "chu-kichi", "kichi", "syo-kichi", "kyo" };
	while (true)
	{
		Point p[6];
		for (int i = 0; i < 3; ++i)
		{
			int a, b, c, d;
			scanf("%d %d %d %d", &a, &b, &c, &d);
			if (i == 0 && !(a | b | c | d))
				goto End;
			p[2*i] = Point(a, b);
			p[2*i + 1] = Point(c, d);
		}

		bool ng = false;
		Point inter_p[3];
		for (int i = 0; i < 3; ++i)
		{
			if (is_interect_linesegments(p[2*i], p[2*i+1], p[2*(i+1)%6], p[(2*(i+1)+1)%6]))
				inter_p[i] = intersectin_point(p[2*i], p[2*i+1], p[2*(i+1)%6], p[(2*(i+1)+1)%6]);
			else
			{
				ng = true;
				break;
			}
		}
		if (ng)
		{
			puts("kyo");
			continue;
		}
		double area = area_triangle(inter_p);
		int i;
		for (i = 0; i < 5; ++i)
			if (area + Eps > thresh[i])
				break;
		puts(kuji[i]);
	}
End:

	return 0;
}