#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;
struct Friend
{
	Friend(int a, int b, int ord) : m_A(a), m_B(b), m_Ord(ord), m_Diff(b - a){}
	int m_A;
	int m_B;
	int m_Diff;
	int m_Ord;
};

struct Result
{
	int m_ConsumedA;
	int m_ConsumedB;
	int m_Ord;
};

bool CompareFriend(const Friend& a, const Friend& b)
{
	return a.m_Diff < b.m_Diff;
}

bool CompareResult(const Result& a, const Result& b)
{
	return a.m_Ord < b.m_Ord;
}


bool CalculateOption(int time, int liters, vector<Friend>& friends, vector<Result>& outResult)
{
	int i;
	int litersConsumed = 0;
	for (i = 0; i < friends.size() && litersConsumed < liters; i++)
	{
		int maxConsume = time / friends[i].m_B;
		Result result;
		if(litersConsumed + maxConsume > liters)
		{
			result.m_ConsumedB = liters - litersConsumed;

			int remainingTime = time - result.m_ConsumedB * friends[i].m_B;
			result.m_ConsumedA = remainingTime / friends[i].m_A;
		}
		else
		{
			result.m_ConsumedB = maxConsume;
			result.m_ConsumedA = 0;
		}

		result.m_Ord = friends[i].m_Ord;
		litersConsumed += result.m_ConsumedB;
		outResult.push_back(result);
	}

	if(litersConsumed < liters)
	{
		return false;
	}
	litersConsumed = outResult.back().m_ConsumedA;
	for( ; i < friends.size(); i++)
	{
		int maxConsume = time / friends[i].m_A;
		Result result;
		result.m_ConsumedA = maxConsume;
		result.m_ConsumedB = 0;
		result.m_Ord = friends[i].m_Ord;
		litersConsumed += result.m_ConsumedA;
		outResult.push_back(result);
	}

	if(litersConsumed < liters)
	{
		return false;
	}

	return true;
}

int main()
{
	vector<Friend> friends;
	int n, liters;
	ifstream f("lapte.in");
	ofstream g("lapte.out");
    f >> n >> liters;
	for (int i = 0; i < n; i++)
	{
		int a, b;
		f >> a >> b;
		friends.push_back(Friend(a, b, i));
	}
	sort(friends.begin(), friends.end(), CompareFriend);

	int minTime = 1;
	int maxTime = max(friends[0].m_A * liters, friends.back().m_B * liters);

	vector<Result> results;
	int i;
	for(i = 1; i <= maxTime; i++)
	{
		if(CalculateOption(i, liters, friends, results))
		{
			break;
		}
		results.clear();
	}
	sort(results.begin(), results.end(), CompareResult);
	g << i << "\n";;
	for(auto& result : results)
	{
		g << result.m_ConsumedA << " " << result.m_ConsumedB << "\n";
	}
    return 0;
}