def partsum(r,l):
    return l*(l+1)//2-(r-1)*r//2
n,x = map(int,input().split())
d = list(map(int,input().split()))
d+=d
curday = 0 
cursorce = 0
ans = 0 
l = 0 
for i in range(n*2):
    curday+=d[i]
    cursorce+=d[i]*(d[i]+1)//2
    while curday>x:
        curday-=d[l]
        cursorce-=d[l]*(d[l]+1)//2
        l+=1
    result = cursorce
    cnt = x- curday
    if l>0:
        result+=partsum(d[l-1]-cnt+1,d[l-1])
    ans = max(ans,result)
print(ans)

#include <iostream>
#include <vector>
typedef long long LL;

using namespace std;

// 计算从 l 到 r 的自然数和：0+ (l+1) + ... + r
LL sumup(int r) {
    return r * (r + 1ll) / 2 ;
}

int main() {
    LL n, x;
    cin >> n >> x;  // 读入 n 和 x，n 是月份数，x 是连续登录的天数
    vector<LL> d(n * 2);  // 创建一个长度为 2 * n 的数组来存储天数

    // 输入每个月的天数，并将数组复制一遍以模拟跨年
    for (int i = 0; i < n; i++) {
        cin >> d[i];
        d[i + n] = d[i];  // 复制数组，处理跨年的情况
    }

    LL ans = 0;  // 用于存储最大金币数
    LL month_Sum = 0;  // 当前滑动窗口的天数和
    LL money = 0;  // 当前滑动窗口的金币数
    LL l = 0;  // 滑动窗口的左边界

    // 滑动窗口从0开始，遍历整个复制后的数组
    for (LL r = 0; r < n * 2; r++) {
        month_Sum += d[r];  // 加入当前月份的天数
        money += sumup(d[r]);  // 加入当前月份的金币数（自然数和）

        // 当滑动窗口内的天数总和超过x时，缩小窗口
        while (month_Sum-d[l] >= x) {
            month_Sum -= d[l];  // 减去左边界的天数
            money -= sumup(d[l]);  // 减去左边界的金币数
            l++;  // 滑动窗口左边界右移
        }

        // 更新答案为最大金币数
        ans = max(ans, money-sumup(month_Sum-x));
    }

    cout << ans << endl;  // 输出最大金币数
    return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 400010;  // 2倍日历数组的最大长度
typedef long long LL;

// 计算从1到n的和，用于金币数量计算
LL get(int n) {
    return (1ll + n) * n / 2;  // 使用公式计算1到n的和
}

int main() {
    LL n, x;
    cin >> n >> x;  // 输入月数和连续登录天数
    
    // 定义2倍长度数组，并输入日历数据
    LL a[N * 2];  // 双倍长度的数组
    for(int i = 0; i < n; i++) {
       cin >> a[i];  // 输入每个月的天数
       a[i + n] = a[i]; // 复制一份，形成双倍数组
    }

    LL s = 0;  // 当前窗口的总天数
    LL res = 0;  // 最优解，最大金币数
    LL t = 0;  // 当前窗口的金币总数

    // 滑动窗口遍历数组
    for(int i = 0, j = 0; i < 2 * n; ++i) {
        s += a[i];  // 更新当前窗口的天数和
        t += get(a[i]);  // 计算当前天数的金币数量并累加到总金币数
        
        // 动态调整窗口，保持总天数不超过x
        while (s - a[j] >= x) {
            s -= a[j];  // 从窗口左侧移除天数
            t -= get(a[j++]);  // 移除相应的金币数量
        }

        // 计算当前窗口金币数并更新最优解
        res = max(res, t - get(s - x));  // 如果窗口的天数小于x，计算缺失部分金币并更新结果
    }
    
    cout << res << endl;  // 输出最大金币数
    return 0;
}

# 计算从 l 到 r 的连续整数和
def sumup(l, r):
    return r * (r + 1) // 2 - l * (l - 1) // 2

# 输入日历长度和连续天数
n, x = map(int, input().split())
d = list(map(int, input().split()))
d += d  # 复制日历数据以处理跨年情况

ans = 0  # 初始化答案为0
cursum = 0  # 当前窗口天数和
cur = 0  # 当前窗口金币总数
l = 0  # 左窗口边界

# 滑动窗口遍历
for i in range(n * 2):
    cursum += d[i]
    cur += d[i] * (d[i] + 1) // 2

    # 若窗口天数和超过 x ，从左边界移除
    while cursum > x:
        cursum -= d[l]
        cur -= d[l] * (d[l] + 1) // 2
        l += 1

    # 计算当前窗口金币数并更新最优解
    curans = cur
    cnt = x - cursum
    if l > 0:
        curans += sumup(d[l - 1] - cnt + 1, d[l - 1])
    ans = max(ans, curans)

print(ans)

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        long x = scanner.nextLong();
        long[] d = new long[2 * n];

        // 读取日历数据并复制一份
        for (int i = 0; i < n; i++) {
            d[i] = scanner.nextLong();
            d[i + n] = d[i];
        }

        long dayCnt = 0;  // 当前窗口的总天数
        long coinSum = 0;  // 当前窗口金币总数
        int j = 0;  // 左窗口边界
        long ans = 0;  // 最大金币数

        // 滑动窗口遍历日历数组
        for (int i = 0; i < 2 * n; i++) {
            dayCnt += d[i];
            coinSum += d[i] * (1 + d[i]) / 2;

            // 动态调整窗口大小
            while (dayCnt > x) {
                dayCnt -= d[j];
                coinSum -= d[j] * (1 + d[j]) / 2;
                j++;
            }

            // 计算当前窗口金币数并更新最优解
            long rest = x - dayCnt;
            long curans = coinSum;
            if (j > 0) {
                curans += sumup(d[j - 1] - rest + 1, d[j - 1]);
            }
            ans = Math.max(ans, curans);
        }

        System.out.println(ans);
    }

    // 计算从 l 到 r 的和，用于补全天数
    public static long sumup(long l, long r) {
        return r * (r + 1) / 2 - l * (l - 1) / 2;
    }
}