program indiana;

const
   MAXK = 100000;

type

   { Datový typ pro haldu }
   THalda = record
      pole  : array[ 1..MAXK div 2 + 1 ] of record
         hodnota : longint;
         id : longint; { Index do odpovídající položky v poli TIndexy }
      end;
      pocet : longint;
   end;

   { Každý prvek si pamatuje index ve své haldě }
   TIndexy = array [ 1..MAXK ] of record
      index : longint;
      halda : (horni, dolni);
   end;

procedure Vymen(var a,b : longint);
var
   x : longint;
begin
   x:=a;
   a:=b;
   b:=x;
end;

{ Opraví podstrom v haldě }
procedure Dolu(var halda : THalda; pozice : longint; var indexy : TIndexy);
var
   potomek        : longint;
   pokracovat     : boolean;
begin
   with halda do begin
      pokracovat:= (2<=pocet) and (2*pozice<=pocet);

      while Pokracovat do begin
         potomek:=2*pozice;

         if potomek < pocet then
            if pole[potomek+1].hodnota < pole[potomek].hodnota then
               potomek:=potomek+1;

         if pole[pozice].hodnota > pole[potomek].hodnota then begin
            Vymen(pole[pozice].hodnota, pole[potomek].hodnota);
            Vymen(pole[pozice].id, pole[potomek].id);
            Vymen(indexy[pole[pozice].id].index, indexy[pole[potomek].id].index);

            pozice:=potomek;
            pokracovat:=2*pozice<=pocet
         end else
            pokracovat:=false
      end;
   end;
end;

{ Opraví cestu ke kořenu haldy }
procedure Nahoru(var halda : THalda; pozice : longint; var indexy : TIndexy);
var
   otec        : longint;
   pokracovat  : boolean;
begin
   with halda do begin
      pokracovat:=pozice>1;

      while Pokracovat do begin
         otec:=pozice div 2;
         if pole[pozice].hodnota < pole[otec].hodnota then begin
            Vymen(pole[pozice].hodnota, pole[otec].hodnota);
            Vymen(pole[pozice].id, pole[otec].id);
            Vymen(indexy[pole[pozice].id].index, indexy[pole[otec].id].index);
            pozice:=otec;
            pokracovat:=pozice>1
         end else
            pokracovat:=false;
      end;
   end;
end;

{ Zajistí, aby maximum v dolní haldě bylo menší nebo rovno minimu v horní haldě }
procedure Vyvaz(var dHalda, hHalda : THalda; var indexy : TIndexy);
var
   pomoc : longint;
begin
   if (hHalda.pocet = 0) then exit;
   while -dHalda.pole[1].hodnota > hHalda.pole[1].hodnota do begin
      indexy[dHalda.pole[1].id].halda := horni;
      indexy[hHalda.pole[1].id].halda := dolni;

      Vymen(dHalda.pole[1].id, hHalda.pole[1].id);

      pomoc:=-dHalda.pole[1].hodnota;
      dHalda.pole[1].hodnota := -hHalda.pole[1].hodnota;
      hHalda.pole[1].hodnota := pomoc;

      Dolu(dHalda, 1, indexy);
      Dolu(hHalda, 1, indexy);
   end;
end;

{ Vrátí aktuální medián }
function Median(var dHalda, hHalda : THalda; var indexy : TIndexy) : longint;
begin
   { Protože nový prvek mohl prijít do jiné haldy, než do té, do které má patřit,
     je nutné haldy vyvážit a teprve poté spočítat medián }
   Vyvaz(dHalda, hHalda, indexy);
   Median := -dHalda.pole[1].hodnota;
end;

var
   N, K, dPocet, hPocet : longint;
   i, j : longint;

   { Dolní halda obsahuje všechna čísla negovaná, takže se chová jako maximální,
     horní halda se chová jako maximální }
   dHalda, hHalda : THalda;

   { Seznam indexu jednotlivých prvku v haldě }
   indexy  : TIndexy;
   zacatek : longint;
   pomoc   : longint;
   maximum : longint;

begin
   readln(N,K);
   dPocet:=K div 2 + 1; { Dolní halda obsahuje vždy o jeden prvek víc }
   hPocet:=K div 2;

   dHalda.pocet := dPocet;
   for i:=1 to dPocet do begin
      read(j);
      dHalda.pole[i].hodnota := -j;
      dHalda.pole[i].id:=i;
      indexy[i].index := i;
      indexy[i].halda := dolni;
   end;

   hHalda.pocet := hPocet;
   for i:=1 to hPocet do begin
      read(hHalda.pole[i].hodnota);
      hHalda.pole[i].id:=i+dPocet;
      indexy[i+dPocet].index := i;
      indexy[i+dPocet].halda := horni;
   end;

   { Vystavení obou hald }
   for i:=dPocet div 2 downto 1 do
      Dolu(dHalda, i, indexy);

   for i:=hPocet div 2 downto 1 do
      Dolu(hHalda, i, indexy);

   zacatek := 1;

   { První medián poslouží jako dočasné maximum }
   maximum := Median(dHalda, hHalda, indexy);

   for i:=K+1 to N do begin
      read(j);

      { Nahrazení nejstaršího prvku z jeho haldy nejnovějším prvkem }
      if indexy[zacatek].halda = dolni then begin
         dHalda.pole[indexy[zacatek].index].hodnota:=-j;
         Nahoru(dHalda, indexy[zacatek].index, indexy);
         Dolu(dHalda, indexy[zacatek].index, indexy);
      end else begin
         hHalda.pole[indexy[zacatek].index].hodnota:=j;
         Nahoru(hHalda, indexy[zacatek].index, indexy);
         Dolu(hHalda, indexy[zacatek].index, indexy);
      end;

      pomoc := Median(dHalda, hHalda, indexy);
      if pomoc > maximum then
         maximum := pomoc;

      inc(zacatek);
      if zacatek > K then
         zacatek := 1;
   end;

   writeln(maximum);
end.