{
name: Gediminas Lukšys
ID: LIT01
password: FULNP
country: Lithuania
email: gedluk@lrtc.lt
}

type
  TEdgeRec = record
    From, FromD, T : longint;
  end;
  TPlatform = record
    Nr, X1, X2, H : longint;
    Left, Right : TEdgeRec;
  end;
  TAnsRec = record
    P, T, D : longint;
  end;

var
  N, SX, SY, Max : longint;
  Plats : array [1..1000] of TPlatform;
  txt : text;
  AnsE : TEdgeRec;
  AnsC : longint;
  Ans : array [1..1000] of TAnsRec;

procedure ReadData;

var i : longint;

begin
  Assign (txt, 'fall.in');
  Reset (txt);
  ReadLn (txt, N, SX, SY, Max);
  for i := 1 to N do
    begin
      Plats[i].Nr := i;
      ReadLn (txt, Plats[i].X1, Plats[i].X2, Plats[i].H);
      Plats[i].Left.T := 0;
      Plats[i].Right.T := 0;
    end;
  Close (txt);
end;

procedure QSort (k1, k2 : longint);

var i, j : longint;
    F, F2 : TPlatform;
begin
  i := k1; j := k2;
  F := Plats[(i+j)div 2];
  repeat
    while F.H < Plats[i].H do
      i := i + 1;
    while F.H > Plats[j].H do
      j := j - 1;
    if i <= j then
      begin
        F2 := Plats[i];
        Plats[i] := Plats[j];
        Plats[j] := F2;
        i := i + 1;
        j := j - 1;
      end;
  until i > j;
  if k1 < j then QSort (k1, j);
  if k2 > i then QSort (i, k2);
end;

procedure Solve;

var MaxH, MaxI : longint;
    i, j : longint;

begin
  MaxH := 0;
  for i := 1 to N do
    with Plats[i] do
      if (X1 <= SX) and (SX <= X2) and (H > MaxH) then
        begin
          MaxH := H;
          MaxI := i;
        end;
  AnsC := 0;
  AnsE.From := 0;
  AnsE.T := maxlongint;
  if MaxH = 0 then
    begin
      AnsE.T := SY;
      exit;
    end;
  with Plats[MaxI] do
    begin
      Left.From := 0;
      Left.T := (SY - MaxH) + (SX - X1);
      Right.From := 0;
      Right.T := (SY - MaxH) + (X2 - SX);
    end;
  for i := 1 to N do
    if Plats[i].Left.T > 0 then
      begin
        {Left}
        MaxH := 0;
        for j := i+1 to N do
          if (Plats[j].X1 <= Plats[i].X1) and (Plats[j].X2 >= Plats[i].X1)
            and (Plats[j].H > MaxH) then
              begin
                MaxH := Plats[j].H;
                MaxI := j;
              end;
        if Plats[i].H - MaxH <= Max then
          begin
            if MaxH = 0
              then if Plats[i].Left.T + Plats[i].H < AnsE.T
                then
                begin
                  AnsE.T := Plats[i].Left.T + Plats[i].H;
                  AnsE.From := i;
                  AnsE.FromD := 0;
                end
                else
              else
              begin
                if Plats[MaxI].Left.T = 0
                  then
                  begin
                    Plats[MaxI].Left.T := Plats[i].Left.T + (Plats[i].H - MaxH)
                      + (Plats[i].X1 - Plats[MaxI].X1);
                    Plats[MaxI].Left.From := i;
                    Plats[MaxI].Left.FromD := 0;
                    Plats[MaxI].Right.T := Plats[i].Left.T + (Plats[i].H - MaxH)
                      + (Plats[MaxI].X2 - Plats[i].X1);
                    Plats[MaxI].Right.From := i;
                    Plats[MaxI].Right.FromD := 0;
                  end
                  else
                  begin
                    if Plats[i].Left.T + (Plats[i].H - MaxH) +
                      (Plats[i].X1 - Plats[MaxI].X1) < Plats[MaxI].Left.T then
                      begin
                        Plats[MaxI].Left.T := Plats[i].Left.T + (Plats[i].H - MaxH)
                          + (Plats[i].X1 - Plats[MaxI].X1);
                        Plats[MaxI].Left.From := i;
                        Plats[MaxI].Left.FromD := 0;
                      end;
                    if Plats[i].Left.T + (Plats[i].H - MaxH) +
                      (Plats[MaxI].X2 - Plats[i].X1) < PLats[MaxI].Right.T then
                      begin
                        Plats[MaxI].Right.T := Plats[i].Left.T + (Plats[i].H - MaxH)
                          + (Plats[MaxI].X2 - Plats[i].X1);
                        Plats[MaxI].Right.From := i;
                        Plats[MaxI].Right.FromD := 0;
                      end;
                  end;
              end;
          end;
        {Right}
        MaxH := 0;
        for j := i+1 to N do
          if (Plats[j].X1 <= Plats[i].X2) and (Plats[j].X2 >= Plats[i].X2)
            and (Plats[j].H > MaxH) then
              begin
                MaxH := Plats[j].H;
                MaxI := j;
              end;
        if Plats[i].H - MaxH <= Max then
          begin
            if MaxH = 0
              then if Plats[i].Right.T + Plats[i].H < AnsE.T
                then
                begin
                  AnsE.T := Plats[i].Right.T + Plats[i].H;
                  AnsE.From := i;
                  AnsE.FromD := 1;
                end
                else
              else
              begin
                if Plats[MaxI].Right.T = 0
                  then
                  begin
                    Plats[MaxI].Left.T := Plats[i].Right.T + (Plats[i].H - MaxH)
                      + (Plats[i].X2 - Plats[MaxI].X1);
                    Plats[MaxI].Left.From := i;
                    Plats[MaxI].Left.FromD := 1;
                    Plats[MaxI].Right.T := Plats[i].Right.T + (Plats[i].H - MaxH)
                      + (Plats[MaxI].X2 - Plats[i].X2);
                    Plats[MaxI].Right.From := i;
                    Plats[MaxI].Right.FromD := 1;
                  end
                  else
                  begin
                    if Plats[i].Right.T + (Plats[i].H - MaxH) +
                      (Plats[i].X2 - Plats[MaxI].X1) < Plats[MaxI].Left.T then
                      begin
                        Plats[MaxI].Left.T := Plats[i].Right.T + (Plats[i].H - MaxH)
                          + (Plats[i].X2 - Plats[MaxI].X1);
                        Plats[MaxI].Left.From := i;
                        Plats[MaxI].Left.FromD := 1;
                      end;
                    if Plats[i].Right.T + (Plats[i].H - MaxH) +
                      (Plats[MaxI].X2 - Plats[i].X2) < Plats[MaxI].Right.T then
                      begin
                        Plats[MaxI].Right.T := Plats[i].Right.T + (Plats[i].H - MaxH)
                          + (Plats[MaxI].X2 - Plats[i].X2);
                        Plats[MaxI].Right.From := i;
                        Plats[MaxI].Right.FromD := 1;
                      end;
                  end;
              end;
          end;
      end;
end;

procedure WriteAnswer;

var i, nr : longint;
    Cur : TEdgeRec;

begin
  if AnsE.From > 0 then
    begin
      Cur := AnsE;
      repeat
        AnsC := AnsC + 1;
        Ans[AnsC].D := Cur.FromD;
        nr := Cur.From;
        Ans[AnsC].P := Plats[Cur.From].Nr;
        if Cur.FromD = 0
          then Cur := Plats[Cur.From].Left
          else Cur := Plats[Cur.From].Right;
        if Cur.From > 0
          then if Ans[AnsC].D = 0
            then if Cur.FromD = 0
              then Ans[AnsC].T := Cur.T - Plats[Cur.From].X1 + Plats[nr].X1
              else Ans[AnsC].T := Cur.T - Plats[Cur.From].X2 + Plats[nr].X1
            else if Cur.FromD = 0
              then Ans[AnsC].T := Cur.T + Plats[Cur.From].X1 - Plats[nr].X2
              else Ans[AnsC].T := Cur.T + Plats[Cur.From].X2 - Plats[nr].X2
          else if Ans[AnsC].D = 0
            then Ans[AnsC].T := Cur.T - SX + Plats[nr].X1
            else Ans[AnsC].T := Cur.T + SX - Plats[nr].X2;
      until Cur.From = 0;
    end;
  assign (txt, 'fall.out');
  rewrite (txt);
  writeln (txt, ansE.T);
  for i := AnsC downto 1 do
    writeln (txt, Ans[i].P, ' ', Ans[i].T, ' ', Ans[i].D);
  Close (txt);
end;

begin
  ReadData;
  QSort (1, N);
  Solve;
  WriteAnswer;
end.