#include<iostream>

#include<algorithm>

#include<vector>

#include<set>

#define MAXN 1930

#define M_4 4

using namespace std;

struct _node

{

    int len;

    int wide;

};

struct _node_ans

{

    int len;

    int wide;

    int area;

};

int _max(int a,int b);

int _max(int a,int b,int c);

int _max(int a,int b,int c,int d);

int compare(const void * i,const void * j);

void fun_1(int index);

void fun_2(int index);

void fun_3(int index);

void fun_4(int index);

void fun_5(int index);

void fun_6(int index);

_node _m[M_4];

int _sub[M_4];

int compare1(const void * i,const void * j);

_node_ans _ans[MAXN];

void init();

int stack_p = ;

int main()

{

    //freopen("acm.acm","r",stdin);

    int i;

    int sum = ;

    int temp;

    for(i = ; i < M_4; ++ i)

    {

        cin>>_m[i].wide;

        cin>>_m[i].len;

    }

    init();

    do

    {

        fun_1(-);

        fun_2(-);

        fun_3(-);

        fun_4(-);

        fun_6(-);

    }while(next_permutation(_sub,_sub+M_4));

    qsort(_ans,stack_p,sizeof(_node_ans),compare);

    temp = _ans[].area;

    for(i = ; i < stack_p; ++ i)

    {

        if(_ans[i].area == temp)

        {

            if(_ans[i].len > _ans[i].wide)

            {

                iter_swap(&_ans[i].len,&_ans[i].wide);

            }

            ++ sum;

        }

        else

            break;

    }

    qsort(_ans,sum,sizeof(_node_ans),compare1);

    cout<<temp<<endl;

    for(i = ; i < sum; ++ i)

    {

        if(i ==  || (_ans[i].len != _ans[i-].len || _ans[i].wide != _ans[i-].wide))

            cout<<_ans[i].len<<" "<<_ans[i].wide<<endl;

    }

}

int compare1(const void * i,const void * j)

{

    return ((_node_ans *)i)->len - ((_node_ans *)j)->len;

}

int compare(const void * i,const void * j)

{

    return ((_node_ans *)i)->area - ((_node_ans *)j)->area;

}

void init()

{

    int i;

    for(i = ; i < M_4; ++ i)

    {

        _sub[i] = i;

    }

}

void fun_1(int index)

{

    ++ index;

    if(index == M_4)

    {

        _ans[stack_p].len = _m[_sub[]].len + _m[_sub[]].len + _m[_sub[]].len + _m[_sub[]].len;

        _ans[stack_p].wide = _max(_m[_sub[]].wide,_m[_sub[]].wide,_m[_sub[]].wide,_m[_sub[]].wide);

        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;

        stack_p ++;

        return;

    }

    fun_1(index);

    iter_swap(&_m[_sub[index]].wide,&_m[_sub[index]].len);

    fun_1(index);

    iter_swap(&_m[_sub[index]].wide,&_m[_sub[index]].len);

}

void fun_2(int index)

{

    ++ index;

    if(index == M_4)

    {

        _ans[stack_p].len =_max(_m[_sub[]].len +_m[_sub[]].len + _m[_sub[]].len,_m[_sub[]].len);

        _ans[stack_p].wide = _max(_m[_sub[]].wide,_m[_sub[]].wide,_m[_sub[]].wide) + _m[_sub[]].wide;

        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;

        stack_p ++;

        return;

    }

    fun_2(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

    fun_2(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

}

void fun_3(int index)

{

    ++ index;

    if(index == M_4)

    {

        _ans[stack_p].len = _m[_sub[]].len + _max(_m[_sub[]].len+_m[_sub[]].len ,_m[_sub[]].len );

        _ans[stack_p].wide = _max(_m[_sub[]].wide,_max(_m[_sub[]].wide,_m[_sub[]].wide)+_m[_sub[]].wide);

        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;

        stack_p ++;

        return;

    }

    fun_3(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

    fun_3(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

}

void fun_4(int index)

{

    ++ index;

    if(index == M_4)

    {

        _ans[stack_p].len = _m[_sub[]].len + _m[_sub[]].len + _max(_m[_sub[]].len,_m[_sub[]].len);

        _ans[stack_p].wide = _max(_m[_sub[]].wide,_m[_sub[]].wide,_m[_sub[]].wide + _m[_sub[]].wide);

        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;

        stack_p ++;

        return;

    }

    fun_4(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

    fun_4(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

}

void fun_6(int index)

{

    ++ index;

    if(index == M_4)

    {

        _ans[stack_p].len =    _max(_m[_sub[]].len+_m[_sub[]].len,_m[_sub[]].len + _m[_sub[]].len,_m[_sub[]].len + _m[_sub[]].len);

        _ans[stack_p].wide = _max(_m[_sub[]].wide+_m[_sub[]].wide,_m[_sub[]].wide+_m[_sub[]].wide,_m[_sub[]].wide+_m[_sub[]].wide);

        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;

        stack_p ++;

        return;

    }

    fun_6(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

    fun_6(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

}

int _max(int a,int b)

{

    if(a > b)

    {

        return a;

    }

    return b;

}

int _max(int a,int b,int c)

{

    a = _max(a,b);

    a = _max(a,c);

    return a;

}

int _max(int a,int b,int c,int d)

{

    return _max(a,_max(b,c,d));

}

void fun_5(int index)

{

    ++ index;

    if(index == M_4)

    {

        _ans[stack_p].len = _m[_sub[]].len + _m[_sub[]].len + _max(_m[_sub[]].len,_m[_sub[]].len);

        _ans[stack_p].wide = _max(_m[_sub[]].wide,_m[_sub[]].wide,_m[_sub[]].wide + _m[_sub[]].wide);

        _ans[stack_p].area = _ans[stack_p].len * _ans[stack_p].wide;

        stack_p ++;

        return;

    }

    fun_5(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

    fun_5(index);

    iter_swap(&_m[_sub[index]].len,&_m[_sub[index]].wide);

}