import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in Actual solution is at the top
 *
 * @author ilyakor
 */
public class Main {

  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    TaskB solver = new TaskB();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskB {

    int n;
    int x;
    int[] a;

    public void solve(int testNumber, InputReader in, OutputWriter out) {
      n = in.nextInt();
      x = in.nextInt();
      a = new int[n];
      for (int i = 0; i < n; ++i) {
        a[i] = in.nextInt();
      }
      // long[] d = new long[n + 1];
      // d[0] = 0;
      // for (int i = 0; i < n; ++i) {
      //     d[i + 1] = Long.MAX_VALUE;
      //     for (int l = 1; l <= i + 1; ++l) {
      //         long cur = a[i];
      //         for (int j = 0; j < l; ++j) {
      //             long x1 = a[i - j];
      //             long x2 = (j == l - 1) ? 0 : a[i - j - 1];
      //             cur += (x1 - x2) * (j + 2L) * (j + 2L);
      //         }
      //         cur += x;
      //         if (cur > 1E15) break;
      //         cur += d[i - l + 1];
      //         if (cur < d[i + 1])
      //             d[i + 1] = cur;
      //     }
      // }
      // long res = d[n];
      // res += (long) x * (long) n;

      // long res = 0;
      // int pos = n - 1;
      // while (pos >= 0) {
      //     long cur = a[pos] + 2L * x;
      //     long cnt = 1;
      //     --pos;
      //     while (pos >= 0) {
      //         long asIs = (cur + a[pos + 1] * (cnt + 1L) * (cnt + 1L)) + (2L * x + a[pos] * 5L);
      //         long next = cur + (a[pos + 1] - a[pos]) * (cnt + 1L) * (cnt + 1L) + a[pos] * (cnt + 2L) * (cnt + 2L) + x;
      //         if (next > asIs) break;
      //         cur += (a[pos + 1] - a[pos]) * (cnt + 1L) * (cnt + 1L) + x;
      //         ++cnt;
      //         --pos;
      //     }
      //     res += cur + a[pos + 1] * (cnt + 1L) * (cnt + 1L);
      // }
      // out.printLine(res);

      long res = Long.MAX_VALUE;

      // long[] D = new long[n + 1];
      // for (int d = 1; d <= n; ++d)
      //     D[d] = calc(d);
      // for (int d = 2; d < n; ++d) {
      //     Assert.assertTrue(D[d] - D[d - 1] <= D[d + 1] - D[d]);
      // }

      int l = 1, r = n;
      while (r - l > 5) {
        int l2r = (l * 2 + r) / 3;
        int lr2 = (l + r * 2) / 3;
        if (calc(l2r) < calc(lr2)) {
          r = lr2;
        } else {
          l = l2r;
        }
      }
      for (int d = l; d <= r; ++d) {
        res = Math.min(res, calc(d));
      }

      out.printLine(res);
    }

    long calc(int d) {
      long res = (long) x * (long) n;
      for (int i = 0; i < n; ++i) {
        if (i / d == 0) {
          res += x;
        }
        if (i + d >= n) {
          res += a[i];
        }
        long w = (n - i - 1) / d + 1L;
        long delta = a[i];
        if (i >= d) {
          delta -= a[i - d];
        }
        res += delta * (w + 1L) * (w + 1L);
      }
      return res;
    }

  }

  static class OutputWriter {

    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
      for (int i = 0; i < objects.length; i++) {
        if (i != 0) {
          writer.print(' ');
        }
        writer.print(objects[i]);
      }
    }

    public void printLine(Object... objects) {
      print(objects);
      writer.println();
    }

    public void close() {
      writer.close();
    }

  }

  static class InputReader {

    private InputStream stream;
    private byte[] buffer = new byte[10000];
    private int cur;
    private int count;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public static boolean isSpace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public int read() {
      if (count == -1) {
        throw new InputMismatchException();
      }
      try {
        if (cur >= count) {
          cur = 0;
          count = stream.read(buffer);
          if (count <= 0) {
            return -1;
          }
        }
      } catch (IOException e) {
        throw new InputMismatchException();
      }
      return buffer[cur++];
    }

    public int readSkipSpace() {
      int c;
      do {
        c = read();
      } while (isSpace(c));
      return c;
    }

    public int nextInt() {
      int sgn = 1;
      int c = readSkipSpace();
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      int res = 0;
      do {
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res = res * 10 + c - '0';
        c = read();
      } while (!isSpace(c));
      res *= sgn;
      return res;
    }

  }
}



Measured memory_bytes: 23892