#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iterator>
#include <assert.h>
using namespace std;

const string file = "lapte";

const string infile = file + ".in";
const string outfile = file + ".out";

const int INF = 0x3f3f3f3f;

vector<int> A;
vector<int> B;

int tMin;
int N;
int L;


vector<vector<int> > Recons;

bool solve(int T)
{

	vector<int> C(L + 1, -1);
	vector<int> D(L + 1, -1);
	C[0] = 0;
	Recons.clear();
	Recons.resize(N, vector<int>(L + 1, -1));

	for(int i = 0; i < N; i++)
	{
		for(int j = 0; j * A[i] <= T; j++)
		{
			int x = (T - j * A[i]) / B[i];

			for(int k = j; k <= L; k++)
			{
				
				if(C[k - j] == -1)
					break;

				if(D[k] <= C[k-j] + x)
				{
					D[k] = C[k-j] + x;
					Recons[i][k] = j;
				}
			}

		}

		C = D;
		fill(D.begin(), D.end(), -1);
	}

	if(C[L] >= L)
		return true;
	return false;
}



void printSol(ostream& fout, int i, int j)
{
	if( i != 0)
		printSol(fout, i-1, j - Recons[i][j]); 
	

	int a = Recons[i][j];
	int b = (tMin - a * A[i])/B[i];
	a = (tMin - b* B[i])/A[i];

	fout << a << " " << b << "\n";
}

int main()
{
	fstream fin(infile.c_str(), ios::in);
	fin >> N >> L;
	A.resize(N);
	B.resize(N);
	
	for(int i = 0; i < N; i++)
	{
		fin >> A[i] >> B[i];
	}
	fin.close();

	
	int st = 0;
	int dr = 1000;
	while(st <= dr)
	{
		int mid = (dr + st)/2;
		if(solve(mid))
		{
			tMin = mid;
			dr = mid - 1;
		}
		else
		{
			st = mid + 1;
		}

	}
	if(solve(tMin) == false)
	{
		assert(false);
	}
	fstream fout(outfile.c_str(), ios::out);
	fout << tMin << "\n";
	printSol(fout, N - 1, L);
	fout.close();
}