program posloupnost;
const MAX:word=100000;
var a:array[1..MAX] of longint;
    soucty:array[0..MAX] of longint;
    index:array[0..MAX] of word;
    X:longint;
    N:word;
type uzel=record
            hodnota:longint;   { hodnota součtu uložená v uzlu }
            aktivni:boolean;   { příznak, zda je hodnota aktivní }
            akt_strom:boolean; { příznak existence aktivních listů v podstromě,
                                 tj. u listu určuje jeho aktivitu }
            index:word;        { určuje délku posloupnosti odp. součtu }
            levy,pravy:^uzel;
          end;
type puzel=^uzel;
var koren:^uzel;

procedure bublej_nahoru(odkud, mez: word);
  { pomocná procedure pro heap-sort - prvek na pozici, odkud
    je zabubláván směrem nahoru v haldě po velikost určenou parametrem mez }
  var j1,j2,k:word;
  begin
    j2:=odkud;
    repeat
      j1:=j2;
      if (2*j1+1<=mez) and (soucty[j2]<soucty[2*j1+1]) then j2:=2*j1+1;
      if (2*j1+1<=mez) and (soucty[j2]=soucty[2*j1+1])
                       and (index[j2]<index[2*j1+1]) then j2:=2*j1+1;
      if (2*j1+2<=mez) and (soucty[j2]<soucty[2*j1+2]) then j2:=2*j1+2;
      if (2*j1+2<=mez) and (soucty[j2]=soucty[2*j1+2])
                       and (index[j2]<index[2*j1+2]) then j2:=2*j1+2;
      k:=soucty[j1]; soucty[j1]:=soucty[j2]; soucty[j2]:=k;
      k:=index[j1]; index[j1]:=index[j2]; index[j2]:=k;
    until j1=j2;
  end;

procedure nacti_a_setrid;
  var i,k:word;
  begin
    readln(N);
    for i:=1 to N do read(a[i]);
    readln(X);
    soucty[0]:=0;
    for i:=1 to N do soucty[i]:=soucty[i-1]+a[i];
    for i:=0 to N do index[i]:=i;
    { heap-sort }
    for i:=N downto 0 do bublej_nahoru(i,N);
    for i:=N downto 1 do
      begin
        k:=soucty[0]; soucty[0]:=soucty[i]; soucty[i]:=k;
        k:=index[0]; index[0]:=index[i]; index[i]:=k;
        bublej_nahoru(0,i-1);
      end;
    for i:=1 to N do
      begin
        if soucty[i-1]=soucty[i] then index[i]:=index[i-1];
      end;
    { ve stromě chceme, aby součty odpovídaly nejkratší možné posloupnosti }
  end;

function postav_strom(prvni, posledni: word):puzel;
  var u:^uzel;
      k:word;
  begin
    new(u);
    k:=(prvni+posledni) div 2;
    u^.hodnota:=soucty[k];
    u^.index:=index[k];
    u^.akt_strom:=false;
    u^.aktivni:=false;
    u^.levy:=nil;
    u^.pravy:=nil;
    if prvni<k then u^.levy:=postav_strom(prvni,k-1);
    if k<posledni then u^.pravy:=postav_strom(k+1,posledni);
    postav_strom:=u
  end;

procedure aktivuj(hodnota: word);
  var u:^uzel;
  begin
    u:=koren;
    u^.akt_strom:=true;
    while true do
      begin
        if hodnota=u^.hodnota then
          begin
            u^.aktivni:=true;
            exit
          end;
        if hodnota<u^.hodnota then
          u:=u^.levy
        else
          u:=u^.pravy;
        u^.akt_strom:=true
      end;
  end;

function nejblizsi_mensi(u: puzel; hodnota: longint): integer;
  var vysledek: integer;
  begin
    if (u=nil) or (not u^.akt_strom) then
      begin
        nejblizsi_mensi:=-1;
        exit
      end;
    if u^.aktivni and (u^.hodnota=hodnota) then
      begin
        nejblizsi_mensi:=u^.index;
        exit
      end;
    if u^.hodnota>hodnota then
      begin
        nejblizsi_mensi:=nejblizsi_mensi(u^.levy,hodnota);
        exit
      end;
    vysledek:=nejblizsi_mensi(u^.pravy,hodnota);
    if vysledek<>-1 then
      begin
        nejblizsi_mensi:=vysledek;
        exit
      end;
    if u^.aktivni then
      begin
        nejblizsi_mensi:=u^.index;
        exit
      end;
    nejblizsi_mensi:=nejblizsi_mensi(u^.levy,hodnota);
  end;

function nejblizsi_vetsi(u: puzel; hodnota:longint): integer;
  var vysledek: integer;
  begin
    if (u=nil) or (not u^.akt_strom) then
      begin
        nejblizsi_vetsi:=-1;
        exit
      end;
    if u^.aktivni and (u^.hodnota=hodnota) then
      begin
        nejblizsi_vetsi:=u^.index;
        exit
      end;
    if u^.hodnota<hodnota then
      begin
        nejblizsi_vetsi:=nejblizsi_vetsi(u^.pravy,hodnota);
        exit
      end;
    vysledek:=nejblizsi_vetsi(u^.levy,hodnota);
    if vysledek<>-1 then
      begin
        nejblizsi_vetsi:=vysledek;
        exit
      end;
    if u^.aktivni then
      begin
        nejblizsi_vetsi:=u^.index;
        exit
      end;
    nejblizsi_vetsi:=nejblizsi_vetsi(u^.pravy,hodnota);
  end;

procedure vyres;
  var soucet: longint;
      opt_soucet: longint;
      opt_od, opt_do: word;
      i: word;
      k: integer;
  begin
    aktivuj(0);
    aktivuj(a[1]);
    soucet:=a[1];
    opt_soucet:=a[1];
    opt_od:=1; opt_do:=1;
    soucty[0]:=0;
    for i:=1 to N do soucty[i]:=soucty[i-1]+a[i];
    for i:=2 to N do
      begin
        soucet:=soucet+a[i];
        k:=nejblizsi_mensi(koren,soucet-X);
        if (k<>-1) and (abs(soucty[i]-soucty[k]-X)<abs(opt_soucet-X)) then
          begin
            opt_soucet:=soucty[i]-soucty[k];
            opt_od:=k+1; opt_do:=i;
          end;
        k:=nejblizsi_vetsi(koren,soucet-X);
        if (k<>-1) and (abs(soucty[i]-soucty[k]-X)<abs(opt_soucet-X)) then
          begin
            opt_soucet:=soucty[i]-soucty[k];
            opt_od:=k+1; opt_do:=i;
          end;
        aktivuj(soucet);
      end;
    writeln(opt_od,' ',opt_do,' ',opt_soucet);
  end;

begin
  nacti_a_setrid;
  koren:=postav_strom(0,N);
  vyres;
end.