open Printf open Scanf
module Lib = struct
  let i32,i64,ist = Int64.(to_int,of_int,to_string)
  let (+$) = (+) let (-$) = (-) let (/$) = (/) let ( *$) = ( * ) let (%$) = (mod)
  let labs = Int64.abs
  let (+),(-),( * ),(/),(mod),(%) = Int64.(add,sub,mul,div,rem,rem)
  let (+=) r v = r := !r + v
  let (-=) r v = r := !r - v
  let ( *= ) r v = r := !r * v
  let (/=) r v = r := !r / v
  let (%=) r v = r := !r % v
  let max_i64,min_i64 = Int64.(max_int,min_int)
  (* math *)
  let ceildiv p q = (p+q-1L) / q
  let rec gcd m n = match m,n with | m,0L -> m | m,n -> gcd n (m mod n)
  let lcm m n = m / gcd m n * n
  module I64_infix = struct
    let (land),(lor),(lxor),lnot,(lsl),(lsr),(asr) =
      let open Int64 in
      (logand),(logor),(logxor),lognot,
      (fun u v -> shift_left u (i32 v)),
      (fun u v -> shift_right u (i32 v)),
      (fun u v -> shift_right_logical u (i32 v))
  end
  (* input *)
  let input_i64_array n = Array.init (i32 n) (fun _ -> Scanf.scanf " %Ld" (fun v -> v))
  let get_i64 _ = Scanf.scanf " %Ld" (fun v -> v)
  let get_2_i64 _ = Scanf.scanf " %Ld %Ld" (fun u v -> u,v)
  let get_3_i64 _ = Scanf.scanf " %Ld %Ld %Ld" (fun u v w -> u,v,w)
  let get_4_i64 _ = Scanf.scanf " %Ld %Ld %Ld %Ld" (fun u v w x -> u,v,w,x)
  let get_5_i64 _ = Scanf.scanf " %Ld %Ld %Ld %Ld %Ld" (fun u v w x y -> u,v,w,x,y)
  let i32_get_int _ = Scanf.scanf " %d" (fun v -> v) let i32_get_2_ints _ = Scanf.scanf " %d %d" (fun u v -> u,v) let i32_get_3_ints _ = Scanf.scanf " %d %d %d" (fun u v w -> u,v,w) let i32_get_4_ints _ = Scanf.scanf " %d %d %d %d" (fun u v w x -> u,v,w,x) let i32_get_5_ints _ = Scanf.scanf " %d %d %d %d %d" (fun u v w x y -> u,v,w,x,y)
  (* utils *)
  external id : 'a -> 'a = "%identity"
  let ( *< ) f g x = f (g x)
  let ( *> ) f g x = g (f x)
  let rv f p q = f q p (* ex. 24 |> rv (/) 6 *)
  let alen a = i64 @@ Array.length a
  let llen l = i64 @@  List.length l
  let string_of_list ?(separator=" ") f ls = ls |> List.map f |> String.concat separator
  let string_of_array ?(separator=" ") f a = a |> Array.to_list |> string_of_list ~separator f
  let char_list_of_string str = let rec f0 i a = if i<0 then a else f0 (i-$1) (str.[i]::a) in f0 (String.length str -$ 1) []
  let string_of_char_list ls = List.fold_left (fun u v -> u ^ (String.make 1 v)) "" ls
  let fail _ = failwith "fail"
  let dx,dy = [|1;0;-1;0|],[|0;1;0;-1|]
  let range l r = let ls = ref [] in for i=i32 l to i32 r do ls := i :: !ls done;!ls |> List.rev
  let cartesian_product u v = u |> List.map (fun p -> List.map (fun q -> p,q) v) |> List.flatten
  let shuffle a = Array.sort (fun _ _ -> (Random.int 3) -$ 1) a
  let binary_search ng ok f = let d = if ng < ok then 1L else -1L in
    let rec f0 ng ok =
      if labs (ok - ng) <= 1L then ok
      else let mid = ng + (ok - ng) / 2L in if f mid then f0 ng mid else f0 mid ok
    in f0 (ng-1L*d) (ok+1L*d)
  let lower_bound a v = binary_search 0L (alen a - 1L) (fun i -> a.(i32 i) >= v)
  let upper_bound a v = binary_search 0L (alen a - 1L) (fun i -> a.(i32 i) >  v)
  let equal_range a v = lower_bound a v, upper_bound a v (* #=snd-fst *)
  let rec fix f x = f (fix f) x
  let fix_memo ?(size=10000) f x =
    let tb = Hashtbl.create ~random:true size in
    let rec f0 x =
      try Hashtbl.find tb x with
      | Not_found -> (let v = f f0 x in Hashtbl.add tb x v; v)
    in f0 x
  (* imperative *)
  let rep f t ?(stride=1L) fbod = let i = ref f in while !i <= t do fbod !i; i := !i + stride done
  let repb f t ?(stride=1L) fbod = let i,c = ref f,ref true in while !i <= t && !c do
    match fbod !i with | `Break -> c := false | `Ok -> i := !i + stride done
  let repm f t ?(stride=1L) m0 fbod =
    let i,c,m = ref f,ref true,ref m0 in
    while !i<=t && !c do match fbod !m !i with
    | `Break -> c := false | `Break_m m' -> (c := false; m := m') | `Ok m' -> m := m'; i := !i + stride done; !m
  let repi f t ?(stride=1) fbod = let i = ref f in while !i <= t do fbod !i; i := !i +$ stride done
  let repib f t ?(stride=1) fbod = let i,c = ref f,ref true in while !i <= t && !c do
    match fbod !i with | `Break -> c := false | `Ok -> i := !i +$ stride done
  let repim f t ?(stride=1) m0 fbod =
    let i,c,m = ref f,ref true,ref m0 in
    while !i<=t && !c do match fbod !m !i with
    | `Break -> c := false | `Break_m m' -> (c := false; m := m') | `Ok m' -> m := m'; i := !i +$ stride done; !m
  let rep_rev f t ?(stride=1L) fbod = rep t f ~stride @@ fun v -> fbod @@ f + t - v
  let repb_rev f t ?(stride=1L) fbod = repb t f ~stride @@ fun v -> fbod @@ f + t - v
  let repm_rev f t ?(stride=1L) m0 fbod = repm f t ~stride m0 @@ fun u v -> fbod u @@ f + t - v
  let repi_rev f t ?(stride=1) fbod = repi t f ~stride @@ fun v -> fbod @@ f +$ t -$ v
  let repib_rev f t ?(stride=1) fbod = repib t f ~stride @@ fun v -> fbod @@ f +$ t -$ v
  let repim_rev f t ?(stride=1) m0 fbod = repim f t ~stride m0 @@ fun u v -> fbod u @@ f +$ t -$ v
  (* output *)
  let print_list_mle f ls = string_of_list f ls |> print_endline
  let print_array_mle f a = string_of_array f a |> print_endline
  let print_list f ls = ls |> List.iter (fun v -> printf "%s " @@ f v); print_newline ()
  let print_array f a = a |> Array.iter (fun v -> printf "%s " @@ f v); print_newline ()
  (* debug *)
  let dump_2darr f a = a |> Array.iter (fun b -> print_array f b)
  let dump_i64_list ls = print_list ist ls
  let dump_i64_array a = print_array ist a
end open Lib open Array

module CumulSumArray = struct
  let make a =
    let ln = Array.length a
    in let a1 = Array.make (ln+$1) 0L in for i=1 to ln do a1.(i) <- a1.(i-$1) + a.(i-$1) done; a1
  let sum l r a = (* 0-origin,closed *)
    if l>r then 0L else (a.(r+$1) - a.(l))
  let sum_1orig l r a = sum (l-$1) (r-$1) a
end
module Deque = struct
  (* let (+$),(-$) = Pervasives.((+),(-)) *)
  type 'a u = {
    mutable prev: 'a cell;
    value: 'a;
    mutable next: 'a cell; }
  and 'a cell = Nil | Cons of 'a u
  type 'a t = {
    mutable length: int;
    mutable head: 'a cell;
    mutable tail: 'a cell; }
  exception Empty
  let empty () = {length=0;head=Nil;tail=Nil}
  let is_empty {length;_} = length=0
  let length {length;_} = length
  let clear q = q.length <- 0; q.head <- Nil; q.tail <- Nil
  let push_rear value q = match q.tail with
  | Nil ->
    let n = Cons {prev=Nil; value; next=Nil} in
    q.length <- 1; q.head <- n; q.tail <- n
  | Cons tail ->
    let n = Cons {prev=q.tail; value; next=Nil} in
    q.length <- q.length+$1; tail.next <- n; q.tail <- n
  let pop_front q = match q.head with
  | Nil -> raise Empty
  | Cons {value;next=Nil;_} -> clear q; value
  | Cons {value;next=Cons c as next;_} ->
    q.length <- q.length-$1; c.prev <- Nil; q.head <- next; value
  let push_front value q = match q.head with
  | Nil ->
    let n = Cons {prev=Nil; value; next=Nil} in
    q.length <- 1; q.head <- n; q.tail <- n
  | Cons head ->
    let n = Cons {prev=Nil; value; next=q.head} in
    q.length <- q.length+$1; head.prev <- n; q.head <- n
  let pop_rear q = match q.tail with
  | Nil -> raise Empty
  | Cons {value;prev=Nil;_} -> clear q; value
  | Cons {value;prev=Cons c as prev;_} ->
    q.length <- q.length-$1; c.next <- Nil; q.tail <- prev; value
  let front q = match q.head with
  | Nil -> raise Empty
  | Cons {value;_} -> value
  let rear q = match q.tail with
  | Nil -> raise Empty
  | Cons {value;_} -> value
  let iter f {head;_} =
    let rec f0 = function | Nil -> () | Cons {value;next;_} -> f value; f0 next
    in f0 head
  let iter_rev f {tail;_} =
    let rec f0 = function | Nil -> () | Cons {value;prev;_} -> f value; f0 prev
    in f0 tail
  let fold f u0 {head;_} =
    let rec f0 u = function | Nil -> u | Cons {value;next;_} -> f0 (f u value) next
    in f0 u0 head
  let of_list ls =
    let q = empty () in List.iter (fun v -> push_rear v q) ls; q
  let to_list q = fold (fun u v -> v::u) [] q |> List.rev
end
open I64_infix
let () =
  let n,k = get_2_i64 0 in
  let a = input_i64_array n in
  let n,k = i32 n,i32 k in
  let cumul = CumulSumArray.make a in
  let res = ref [] in
  repi 0 (n-$1) (fun l ->
    repi l (n-$1) (fun r ->
      let sum = CumulSumArray.sum l r cumul in
      res := sum :: !res
    )
  );
  res := List.sort compare !res |> List.rev;
  (* print_list ist !res; *)
  let res = of_list !res in
  let mx = ref 0L in
  repi 0 ((min 100 @@ length res)-$1) (fun s ->
    let tmp = ref res.(s) in
    repi 0 (k-$1) (fun i -> tmp := !tmp land try res.(i+$s) with _ -> 0L);
    (* printf "%Ld\n" !mx; *)
    mx := max !mx !tmp
  );
  printf "%Ld\n" @@ !mx


  (*
  sort (fun u v -> compare v u) res;
  let q = Deque.empty () in

  let l,r,len = ref 0,ref 0,length res in
  let rsucc q r =
    while (not @@ Deque.is_empty q) && (res.(Deque.rear q) >= res.(r)) do
      Deque.pop_rear q |> ignore
    done; Deque.push_rear r q in
  let lsucc (q: int Deque.t) l =
    if Deque.front q = l then Deque.pop_front q |> ignore in
  while !r < k do
    rsucc q !r; r := !r +$ 1;
  done;
  let cand = ref [] in
  while !r < len do
    rsucc q !r; r := !r +$ 1;
    lsucc q !l; l := !l +$ 1;
    cand := (res.(Deque.front q)) :: !cand
  done;
  print_list ist !cand *)

  (* let l,r = ref 0,ref 0 in
  let n,k = i32 n,i32 k in
  let max = ref 0L in
  repi 0 (n-$1) (fun l ->
    let v = ref a.(l) in
    repib 0 (n-$1) (fun r ->
      v := !v land a.(r);
      if !v < !max then `Break
      else if !v > !max then (max := !v; `Ok)
      else `Ok
    )
  );
  printf "%Ld\n" @@ !max *)








