#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <bitset>
#define NMAX 250

using namespace std;

struct punct
{
    int x,y;
    int index;
    bool operator!=(punct p)
    {
        return p.x!=x && p.y!=y;
    }
} p[NMAX];

int n;

punct most_left;


inline double det(punct a, punct b,punct c)
{
    return (a.x-b.x)*(b.y-c.y) - (a.y-b.y)*(b.x-c.x);
}

inline bool comparator(punct a,punct b)
{
    return det(a,b,most_left) < 0;
};


void citire()
{
    scanf("%d",&n);
    for(int i=0; i<n; i++)
    {
        scanf("%d %d ",&p[i].x,&p[i].y);
        p[i].index=i;
    }

}

bool semiplan_st(int i,int j,punct q)
{
    return det(p[i],p[j],q)>0;
}
bool semiplan_dr(int i,int j, punct q)
{
    return det(p[i],p[j],q)<0;
}


punct first(vector<punct>stiva)
{
    return stiva[stiva.size()-1];
}

punct second(vector<punct>stiva)
{
    return stiva[stiva.size()-2];
}


vector<punct> hull(vector<punct>pct)
{
    int most_left_index = 0;


    vector<punct>stiva;

    most_left = pct[0];

    for(int i=1;i<pct.size();i++)
    {
        if(pct[i].x < most_left.x)
        {
            most_left = pct[i];
            most_left_index = i;
        }
    }

    swap(pct[most_left_index],pct[0]);
    sort(pct.begin()+1,pct.end(),comparator);

    stiva.push_back(pct[0]);
    stiva.push_back(pct[1]);

    for (int i = 2; i < pct.size(); i++)
    {
        while (stiva.size() >= 2 && det(second(stiva), first(stiva), pct[i]) > 0)
            stiva.pop_back();
        stiva.push_back(pct[i]);
    }

    vector<punct>result;

    for (int i = stiva.size()-1; i >= 0; i--)
        result.push_back(stiva[i]);

    return result;
}

inline double triangle_area(punct a,punct b)
{
    return (a.y+b.y)*(b.x-a.x);
}

double modul(double d)
{
    return d>0?d:-d;
}

double polygon_area(vector<punct>poly)
{
    double total_area = 0;

    for(int i=0;i<poly.size()-1;i++)
        total_area+=triangle_area(poly[i],poly[i+1]);

    total_area+=triangle_area(poly[poly.size()-1],poly[0]);

    total_area/=2;

    return modul(total_area);
}

double min_difference = 9999;

vector<punct>hull_ion,hull_vasile;

char who[NMAX];

int main()
{
    freopen("gradina.in","r",stdin);
    freopen("gradina.out","w",stdout);
    citire();

    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        {
            if(i!=j)
            {
                vector<punct> st,dr;
                for(int k=0;k<n;k++)
                {
                    if(semiplan_st(i,j,p[k]))
                    {
                        st.push_back(p[k]);
                    }
                    else if(semiplan_dr(i,j,p[k]))
                    {
                        dr.push_back(p[k]);
                    }
                }

                st.push_back(p[i]);
                dr.push_back(p[j]);

                vector<punct>hull_st = hull(st);
                vector<punct>hull_dr = hull(dr);

                if(hull_dr.size()==dr.size() && hull_st.size()==st.size())
                {
                    double area_st = polygon_area(hull_st);
                    double area_dr = polygon_area(hull_dr);

                    if(modul(area_st-area_dr) < min_difference)
                    {
                        min_difference = modul(area_st-area_dr);
                        hull_ion  = hull_dr;
                        hull_vasile = hull_st;
                    }
                }
            }
        }
        printf("%.1lf\n",min_difference);



    for(int i=0;i<hull_ion.size();i++)
        who[hull_ion[i].index]='I';


    for(int i=0;i<hull_vasile.size();i++)
        who[hull_vasile[i].index]='V';

    who[hull_ion.size()+hull_vasile.size()]=0;

    printf("%s",who);

    return 0;
}