{
  Persikėlimas per kanalą

  Funkcijos kitimo analizė. Perrinkimas mažiems intervalams.

  O(logN) Omega(1) Theta(logN)

  Esmė:
    pagal dvi gretimas reikšmes nustatoma, ar f-ja tame taške
    didėja, ar mažėja. Tikrinami pradinio intervalo kraštai
    ir vidurys. Galimi tokie variantai:
    Kairė Vidurys Dešinė      Išvada
    ------ ------- --------   ---------------------------------
      /       ?        /      Minimumas yra int-lo kairė (K)
      \       ?        \      Minimumas yra int-lo dešinė (D)
      /       ?        \      Minimumas yra min(K,D)
      \       /        /      Minimumas yra int-le [K,V] (R)
      \       \        /      Minimumas yra int-le [V,D] (R)

    (R) - rekursiškai tikrinti naująjį intervalą iš naujo
     ?  - kitimas nesvarbus
}

program persik3;

const
  PERR_INT = 8; { Mažiausias intervalo plotis, kai nenaudojamas perrinkimas }
  
var
  N, D, U, V: longint; { Pradiniai duomenys }
  R: longint;          { Rezultatas }
  sqrD: longint;       { Tarpinė reikšmė: sqr(D) }
  
{ Duomenų įvedimas }
procedure ivesti_duom;
var
  f: text;
begin
  assign(f, 'kanalas.dat');
  reset(f);
  readln(f, N, D, U, V);
  close(f);
end;

var
  iK, iD: longint; { Intervalo Kairė ir Dešinė, 0 <= iK < iD < N }

{ Randa minimumą perrenkant visas reikšmes }
procedure rasti_min;

  
  { Laikas, kurį keliaus valtininkas (prieplaukos numeruojamos 0..N-1) }
  function t(x: longint): double;
  begin
    t := sqrt( sqr(1.0 * x) * 1e+6 + sqrD ) / U + (N - 1 - x) * 1.0e+3 / V;
  end;

  { Didėjimo/Mažejimo f-a: grąžina 1 arba -1 }
  function dt(x, y: longint): longint;
  begin
    if t(x) < t(y) then dt := 1
                   else dt := -1;
  end;

  { Grąžina tą reiksmę, su kuria f-a t() yra mažesnė }
  function min(x, y: longint): longint;
  begin
    if t(x) < t(y) then min := x
                   else min := y;
  end;
  
  { Intervalo tikrinimo procedūra: perrinkimas }
  procedure tikr_perrink;
  var
    i: longint;
    x, Rt: double;
  begin
    R := iK; Rt := t(R);
    for i := iK + 1 to iD do
    begin
      x := t(i);
      if x < Rt then
      begin
        R := i;
        Rt := x;
      end;    
    end;
  end;

  { Intervalo tikrinimo procedūra: rekursija }
  procedure tikr_rekurs;
  var
    iV: longint; { Int-lo vidurys }
    dK, dV, dD: longint; { dt(iK) dt(iV) dt(iD) }
  label
    Rekursija;
  begin
  Rekursija:
    if iD - iK < PERR_INT then
      tikr_perrink
    else
    begin
      iV := (iD + iK) div 2;
      dK := dt(iK, iK + 1);
      dD := dt(iD - 1, iD);
      if (dK = dD) or ((dK > 0) and (dD < 0)) then
        R := min(iK, iD)
      else
      begin
        dV := dt(iV, iV + 1);
        if dV > 0 then  { \ / / }
        begin
          iK := iK {+ 1};
          iD := iV;
        end
        else            { \ \ / }
        begin
          iK := iV + 1;
          iD := iD - 1;
        end;
        goto Rekursija;
      end;
    end;
  end;
  
begin
  sqrD := sqr(D);
  iK := 0; iD := N - 1;
  tikr_rekurs;
  inc(R);
end;

{ Išvedamas rezultatas - prieplaukos numeris R }
procedure isvesti_rez;
begin
  writeln(R);
end;

begin
  ivesti_duom;
  rasti_min;
  isvesti_rez;
end.