#include <fstream>
#include <algorithm>
#include <iostream>
#include <vector>
#include <bitset>
#include <iomanip>

#define NMAX 250
//#define uint unsigned

using namespace std;

ifstream in("gradina.in");
ofstream out("gradina.out");

struct punct
{
    int x,y;
    int index;
} 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;
};

inline void citire()
{
    in>>n;
    for(int i=0; i<n; i++)
    {
        in>>p[i].x>>p[i].y;
        p[i].index=i;
    }

}

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

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

    vector<punct>stiva;

    most_left = pct[0];

    for(uint 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 (uint i = 2; i < pct.size(); i++)
    {
        while (stiva.size() >= 2 && det(stiva[stiva.size()-2], stiva.back(), pct[i]) > 0)
            stiva.pop_back();
        stiva.push_back(pct[i]);
    }
    return stiva;
}

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

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

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

    for(uint 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 = 0x3f3f3f3f;

vector<punct>hull_ion,hull_vasile;

char who[NMAX];

int main()
{
    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;
                    }
                }
            }
        }


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

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

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

    out<<setiosflags(ios::fixed)<<setprecision(1)<<min_difference<<'\n'<<who;

    return 0;
}