#include <iostream>
#include <vector>
#include <cmath>

#define EPS 1.0E-9

struct Point {
    double x;
    double y;
};

struct Polar {
    double ro;
    double fi;
};

enum Orientation {COLLINEAR, POSITIVE, NEGATIVE};

double scalar_product(const std::vector<double> &a, 
                      const std::vector<double> &b) 
{
    const int n = a.size();

    double sum = 0;
    for (int i = 0; i < n; i++) {
        sum += a[i] * b[i];
    }

    return sum;
}

double scalar_product(const Point &a, 
                      const Point &b) 
{
    return a.x * b.x + a.y * b.y;
}

void print(const Point &a) 
{
    std::cout << "Point["
              << "x="<< a.x
              << ", y=" << a.y 
              << "]" << std::endl;
}

void print(const Polar &a) 
{
    std::cout << "Polar[" 
              << "ro=" << a.ro 
              << ", fi=" << a.fi 
              << "]" << std::endl;
}

void print(const std::vector<double> &a) 
{
    std::cout << "Vector[";
    for (int i = 0; i < a.size(); i++) {
        std::cout << a[i];
        if (i != a.size() - 1) {
            std::cout << ", "; 
        }
    }
    std::cout << "]" << std::endl;
        
}

std::vector<double> vector_product(const std::vector<double> &a, 
                                   const std::vector<double> &b) 
{
    return {
        a[1] * b[2] - a[2] * b[1],
        a[2] * b[0] - a[0] * b[2],
        a[0] * b[1] - a[1] * b[0]
    };
}

Polar polar(const Point& a) 
{
    return {
        sqrt(a.x * a.x + a.y * a.y),
        atan(a.y / a.x)
    };
}

Point point(const Polar& p) 
{
    return {
        p.ro * cos(p.fi),
        p.ro * sin(p.fi)
    };
}

double distance(const Point &a, 
                const Point &b)
{
    const double dx = b.x - a.x;
    const double dy = b.y - a.y;
    return sqrt(dx * dx + dy * dy);
}

double area_bad(double a, double b, double c) 
{
    const double s = (a + b + c) / 2;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

double area_bed(const Point &a, 
                const Point &b, 
                const Point &c) 
{
    return area_bad(distance(a, b), 
                    distance(b, c), 
                    distance(c, a));
}

double area(const Point &a, 
            const Point &b, 
            const Point &c) 
{
    return abs(
            (a.x - c.x) * (b.y - c.y) - 
            (a.y - c.y) * (b.x - c.x)
        ) / 2;
}

double distance_of_line(const Point &a, 
                        const Point &b, 
                        const Point &c) 
{
    return abs(
            (a.x - c.x) * (b.y - c.y) - 
            (a.y - c.y) * (b.x - c.x)
        ) / distance(a, b);
}

bool colinear(const Point &a, 
              const Point &b, 
              const Point &c)
{
    if (area(a, b, c) < EPS)
        return true;

    return false;
}

Orientation orientation(const Point &a, 
                        const Point &b, 
                        const Point &c) 
{
    double d = (a.x - c.x) * (b.y - c.y) - 
               (a.y - c.y) * (b.x - c.x);

    if (d < -EPS) {
        return NEGATIVE;
    } else if (d > EPS) {
        return POSITIVE;
    }

    return COLLINEAR;
}

bool same_side(const Point &a, 
               const Point &b, 
               const Point &c, 
               const Point &d)
{
    const auto o1 = orientation(a, b, c);
    const auto o2 = orientation(a, b, d);

    if ((o1 == POSITIVE && o2 == POSITIVE) ||
        (o1 == NEGATIVE && o2 == NEGATIVE)) {
            return true;
    }

    return false;
}

bool on_segment(const Point &a, 
                const Point &b, 
                const Point &c)
{
    if (std::min(a.x, b.x) <= c.x <= std::max(a.x, b.x) &&
        std::min(a.y, b.y) <= c.y <= std::max(a.y, b.y)) {
            return true;
    }

    return false;
}

bool intersects(const Point &a, 
                const Point &b, 
                const Point &c, 
                const Point &d) 
{
    const auto o1 = orientation(a, b, c);
    const auto o2 = orientation(a, b, d);
    const auto o3 = orientation(a, c, d);
    const auto o4 = orientation(b, c, d);

    if (((o1 == POSITIVE && o2 == NEGATIVE)  ||
         (o2 == POSITIVE && o1 == NEGATIVE)) && 
        ((o3 == POSITIVE && o4 == NEGATIVE)  ||
         (o4 == POSITIVE && o3 == NEGATIVE))) {
            return true;
    }

    if (o1 == COLLINEAR && on_segment(a, b, c)) {
        return true;
    }
    if (o2 == COLLINEAR && on_segment(a, b, d)) {
        return true;
    }
    if (o3 == COLLINEAR && on_segment(c, d, a)) {
        return true;
    }
    if (o4 == COLLINEAR && on_segment(c, d, b)) {
        return true;
    }

    return false;
}

bool inside_triangle(const Point &a, const Point &b, const Point &c, const Point &p)
{
    const auto o1 = orientation(a, b, p);
    const auto o2 = orientation(b, c, p);
    const auto o3 = orientation(c, a, p);

    if ((o1 == POSITIVE && o2 == POSITIVE && o3 == POSITIVE) ||
        (o1 == NEGATIVE && o2 == NEGATIVE && o3 == NEGATIVE)) {
            return true;
    }

    return false;
}

int main(int argc, const char *argv[])
{
    Tacka a = {0., 0.};
    Tacka b = {0., 1.};
    Tacka c = {0., 3.};

    Orientation ori = orientation(a, b, c);
    if (ori == POZITIVNA) {
        cout << "poz" << endl;
    } else if (ori == NEGATIVNA) {
        cout << "neg" << endl;
    } else {
        cout << "koli" << endl;
    }
    
    return 0;
}