{
TASK:wireless
LANG:Pascal
}
program wireless;

const
	MAXN				= 2000;
	INF				= 1000000000;

type
	Integer				= LongInt;
	TAnswRecord			= record
		fr, sig			: Integer;
	end;

var
	G				: Array [1 .. MAXN, 1 .. MAXN] of Integer;
	used				: Array [1 .. MAXN] of Boolean;
	backB				: Array [1 .. MAXN] of TAnswRecord;
	backC				: Array [1 .. MAXN] of TAnswRecord;
	bb, bc				: Integer;
	lastb, lastc			: Integer;
	ans				: Array [1 .. MAXN] of TAnswRecord;
	D				: Array [1 .. MAXN] of Integer;
	N, A, B, C			: Integer;
	i, j, k				: Integer;
	dest, l				: Integer;

procedure readInput;
begin
	readln(N, A, B, C);
	for i := 1 to N do begin
		for j := 1 to N do
			G[i, j] := INF;
		used[i] := False;
	end;
	for i := 1 to N do begin
		read(k);
		for j := 1 to K do begin
			read(dest, l);
			G[i, dest] := l;
		end;
		readln;
	end;
end;

function minv(a, b: Integer): Integer;
begin
	if (a > b) then
		minv := b
	else
		minv := a;
end;

function max(a, b: Integer): Integer;
begin
	if (a > b) then
		max := a
	else
		max := b;
end;

procedure Solve;
var
	cu				: Integer;
	lto				: Integer;
	min, imin			: Integer;
	found				: Boolean;
begin
	used[A] := True;
	for i := 1 to N do begin
		D[i] := G[A, i];
                ans[i].fr := A;
                ans[i].sig := G[A, i];
        end;
	lto := -1;
	ans[A].fr := -1;
	D[A] := 0;
	for k := 1 to (N - 1) do begin
		min := INF + 1;
		for i := 1 to N do
			if (not used[i]) and (D[i] < min) then begin
				min := D[i];
				imin := i;
			end;
		cu := imin;
		used[cu] := True;
		if (used[C] and used[B]) then
			break;
		for i := 1 to N do
			if (G[cu, i] <> INF) then
				for j := 1 to N do
					if (G[cu, j] <= G[cu, i]) and (D[j] >= D[cu] + G[cu, i]) then begin
						D[j] := D[cu] + G[cu, i];
						ans[j].fr := cu;
						ans[j].sig := G[cu, i];
					end;
	end;
	bb := 0;
	cu := B;
	while (ans[cu].fr <> -1) do begin
		bb := bb + 1;
		backB[bb].fr := ans[cu].fr;
		backB[bb].sig := ans[cu].sig;
		cu := ans[cu].fr;
	end;

	bc := 0;
	cu := C;
	while (ans[cu].fr <> -1) do begin
		bc := bc + 1;
		backC[bc].fr := ans[cu].fr;
		backC[bc].sig := ans[cu].sig;
		cu := ans[cu].fr;
	end;

	found := False;
	for i := 1 to bb do begin
		for j := 1 to bc do
			if (backB[i].fr = backC[j].fr) then begin
				found := True;
				lto := D[backB[i].fr] + minv(backB[i].sig, backC[j].sig);
				lastb := i;
				lastc := j;
				break;
			end;
		if (found) then
			break;
	end;
	writeln(bc + bb - (bb - lastb + 1), ' ', D[B] + D[C] - lto);
	for i := bb downto (lastb + 1) do
		writeln(backB[i].fr, ' ', backB[i].sig);
	writeln(backB[lastb].fr, ' ', max(backB[lastb].sig, backC[lastc].sig));
	for i := lastb - 1 downto 1 do
		writeln(backB[i].fr, ' ', backB[i].sig);
	for i := lastc - 1 downto 1 do
		writeln(backC[i].fr, ' ', backC[i].sig);		
end;

begin
	readInput;
	Solve;
end.