Snuke lives in another world, where slimes are real creatures and kept by some people. Slimes come in N colors. Those colors are conveniently numbered 1 through N. Snuke currently has no slime. His objective is to have slimes of all the colors together.

Snuke can perform the following two actions:

* Select a color i (1≤i≤N), such that he does not currently have a slime in color i, and catch a slime in color i. This action takes him a_i seconds.

* Cast a spell, which changes the color of all the slimes that he currently has. The color of a slime in color i (1≤i≤N-1) will become color i+1, and the color of a slime in color N will become color 1. This action takes him x seconds.




Find the minimum time that Snuke needs to have slimes in all N colors.

Constraints

* 2≤N≤2,000
* a_i are integers.
* 1≤a_i≤10^9
* x is an integer.
* 1≤x≤10^9

Input

The input is given from Standard Input in the following format:


N x
a_1 a_2 ... a_N


Output

Find the minimum time that Snuke needs to have slimes in all N colors.

Examples

Input

2 10
1 100


Output

12


Input

3 10
100 1 100


Output

23


Input

4 10
1 2 3 4


Output

10
#if !defined(__clang__) && defined(__GNUC__)
#include <bits/stdc++.h>
#else
#include <cstdlib>
#include <climits>
#include <iostream>
#include <cstdint>
#include <vector>
#include <string>
#include <complex>
#include <bitset>
#include <queue>
#include <deque>
#include <stack>
#include <utility>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <regex>
#endif //  !defined(__clang__) && defined(__GNUG__)
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/multi_array.hpp>
#include <boost/optional.hpp>

using namespace std;

int sub_modn(int a, int b, int m) {

    if (b > a) {
        return b - a;
    }
    else {
        return m - (a - b);
    }
}

int main()
{
    int64_t N, X;
    std::cin >> N >> X;

    std::vector<int64_t> A;
    for (size_t i = 0; i < N; ++i) {
        int64_t t;
        std::cin >> t;
        A.push_back(t);
    }

    auto spawn = std::min_element(A.begin(), A.end());
    auto spawnIdx = std::distance(A.begin(), spawn);

    struct Cost {
        int64_t cost;
        int64_t spawnCost;
        int64_t shiftCount;
    };

    std::vector<Cost> costs(N);
    int64_t spawnCost = 0;

    costs[spawnIdx] = { A[spawnIdx], A[spawnIdx], 0};

    for (int64_t i = spawnIdx + 1; i < N; ++i) {
        if (A[i] > costs[i-1].cost + X) {
            costs[i] = { costs[i-1].cost + X, costs[i-1].spawnCost, costs[i-1].shiftCount+1};
        }
        else {
            costs[i] = { A[i], A[i], 0};
        }
    }

    if (A[0] > costs[N-1].cost + X) {
        costs[0] = { costs[N-1].cost + X, costs[N-1].spawnCost, costs[N-1].shiftCount+1};
    }
    else {
        costs[0] = { A[0], A[0], 0};
    }

    for (int64_t i = 1; i < spawnIdx; ++i) {
        if (A[i] > costs[i-1].cost + X) {
            costs[i] = { costs[i-1].cost + X, costs[i-1].spawnCost, costs[i-1].shiftCount+1};
        }
        else {
            costs[i] = { A[i], A[i], 0};
        }
    }

    auto shift = std::max_element(costs.begin(), costs.end(), [](auto a, auto b) {
            return a.shiftCount < b.shiftCount;
        })->shiftCount;

    auto sum = std::accumulate(costs.begin(), costs.end(), 0LL, [](auto init, auto i) {
            return init + i.spawnCost;
        });

    std::cout << sum + shift*X << std::endl;

    return 0;
}
