global using global::System;
global using global::System.Collections.Generic;
global using global::System.IO;
global using global::System.Linq;
global using global::System.Net.Http;
global using global::System.Threading;
global using global::System.Threading.Tasks;

namespace vasa
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int n, k, x;
            string[] ulaz = Console.ReadLine().Split(" ");
             n = int.Parse(ulaz[0]);
             k = int.Parse(ulaz[1]);
             x = int.Parse(ulaz[2]);

            int[] niz = new int[n];
            int[] prefiksne = new int[n+1];
            ulaz = Console.ReadLine().Split(" ");


            int suma = 0;
            prefiksne[0] = 0;
            for (int i = 0; i < n; i++)
            {
                niz[i] = int.Parse(ulaz[i]);
                suma += niz[i];
                prefiksne[i+1] = suma;
            }

            // test prefiksne :))
            /*
            foreach(int s in prefiksne)
            {
                Console.Write("{0} ", s);
            }
            Console.WriteLine();

            */




            // za svaki podniz
            for (int i = 0; i < n-k+1; i++) // i je pocetak
            {
                //Console.WriteLine("Test - pocetak i {0}", i);
                int[] p = new int[k];
                int aura = 0;
                int aura2 = 0;
                int x2 = x;
                int x3 = x - 1;
                for (int j = 0; j < k; j++)
                {
                    p[j] = prefiksne[i + j + 1] - prefiksne[i];
                    // a treba da ima max vrednost
                    // zato sa najvecim c (x)
                    // mnozimo najvredniji podskup

                }

                // test prefiksne
                /*
                foreach (int s in p)
                {
                    Console.Write("{0} ", s);
                }
                Console.WriteLine();
                */



                int max = p[k - 1] - p[k - 2]; // stavljamo na zadnji element
                int pokazivac = k - 1; // pokazuje na zadnji
                int pok = k - 1; // pokazuje na poslednji moguci u njegovoj kategoriji
                int najbolji = k - 1;

                
                while (x2 > 1) // dok nije preostala jedna kategorija
                {
                    while (pok >= x2 - 1) // sve dok je unutar granica
                    {
                        if (p[pokazivac] - p[pok - 1] > max)
                        {
                            max = p[pokazivac] - p[pok - 1];
                            najbolji = pok;
                        }
                        pok--;
                    }
                    //kada nadjemo najbolju poziciju za secenje
                    aura += x2 * max;
                    //Console.WriteLine("Aura nova {0}", aura);
                    x2--; // smanjuje se broj kategorija
                    pokazivac = najbolji - 1;
                    pok = pokazivac;
                    if(pokazivac > 0)
                        max = p[pokazivac] - p[pokazivac - 1];
                    najbolji = pokazivac;
                }
                aura += p[pokazivac];
                //Console.WriteLine("Aura nova {0}", aura);

                // moze da poveca c i na samom kraju cele operacije
                // sto znaci da zadnji clan podskupa mozemo
                // da oduzmemo jednom i  da vidimo da li nam to poboljsava uslove




                max = p[k - 1] - p[k - 2]; // stavljamo na zadnji element
                pokazivac = k - 1; // pokazuje na zadnji
                pok = k - 1; // pokazuje na poslednji moguci u njegovoj kategoriji
                najbolji = k - 1;
                
                while (x3 > 1) // dok nije preostala jedna kategorija
                {
                    while (pok >= x3 - 1) // sve dok je unutar granica
                    {
                        if (p[pokazivac] - p[pok - 1] > max)
                        {
                            max = p[pokazivac] - p[pok - 1];
                            najbolji = pok;
                        }
                        pok--;
                    }
                    //kada nadjemo najbolju poziciju za secenje
                    aura2 += x3 * max;
                    //Console.WriteLine("Aura nova {0}", aura);
                    x3--; // smanjuje se broj kategorija
                    pokazivac = najbolji - 1;
                    pok = pokazivac;
                    if (pokazivac > 0)
                        max = p[pokazivac] - p[pokazivac - 1];
                    najbolji = pokazivac;
                }
                aura2 += p[pokazivac];
                //Console.WriteLine("Aura nova {0}", aura);

                if (aura2 > aura) aura = aura2;

                Console.Write(aura + " ");
            }

        }
    }
}