// Pseudocode approach:
// 1. Tính mảng tổng tiền tố S để lấy tổng dãy con O(1)
// 2. Liệt kê tất cả các ước k của X sao cho 1 <= k <= N
// 3. Với mỗi k:
//    - Target = X / k
//    - Tạo map đếm tần suất các tổng dãy con độ dài k (coi như hash map)
//    - Duyệt qua tất cả các dãy con độ dài k, cập nhật map
//    - Duyệt lại map, với mỗi t tổng value, nếu value <= Target, tìm số cặp có tổng = Target
//      (cần count[value] * count[Target - value] nhưng phải xử lý trùng lặp)

// Cấu trúc chính:
for k in divisors of X:
  if k > N: continue
  target = X / k
  map<long long, int> freq
  for i = 1 to N - k + 1:
    sum = S[i+k-1] - S[i-1]
    freq[sum]++
  for each (sum, count) in freq:
    if sum * 2 == target:
       ans += count * (count - 1) / 2
    else if sum < target:
       ans += count * freq[target - sum]

#include <bits/stdc++.h>
using namespace std;
using int64 = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int N;
    int64 X;
    if(!(cin >> N >> X)) return 0;
    vector<int64> P(N+1);
    for(int i=1;i<=N;i++) cin >> P[i];

    // Tính tổng tiền tố
    vector<int64> pref(N+1, 0);
    for(int i=1;i<=N;i++) pref[i] = pref[i-1] + P[i];

    // Liệt kê các ước k của X
    vector<int> divisors;
    for(int64 d=1; d*d<=X; ++d) {
        if(X % d == 0) {
            if(d <= N) divisors.push_back((int)d);
            int64 d2 = X / d;
            if(d2 != d && d2 <= N) divisors.push_back((int)d2);
        }
    }

    int64 answer = 0;
    for(int k : divisors) {
        int64 target = X / k;
        if(target <= 0) continue;

        // Tối ưu: Nếu target quá lớn, ta có thể prune (ví dụ target > max_sum_possible)
        // max_sum_possible = sum(P) (chỉ đúng nếu k=N), chung quy lại target không thể quá lớn.
        // Tuy nhiên, dùng map vẫn an toàn.

        unordered_map<int64, int> freq;
        freq.reserve(N - k + 1); // Giảm thời gian rehash

        // Duyệt các dãy con độ dài k
        for (int i = 1; i <= N - k + 1; ++i) {
            int64 sum = pref[i + k - 1] - pref[i - 1];
            freq[sum]++;
        }

        // Đếm số cặp
        for (auto const& [sum, count] : freq) {
            int64 rem = target - sum;
            if (rem < sum) continue; // Tránh đếm trùng, chỉ xét sum <= rem
            if (rem == sum) {
                answer += (int64)count * (count - 1) / 2;
            } else {
                if (freq.count(rem)) {
                    answer += (int64)count * freq[rem];
                }
            }
        }
    }
    cout << answer;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
using int64 = long long;

const int MAX_VAL = 2000005; // Đủ lớn để chứa giá trị tổng (max X ~ 10^6)
int cnt[MAX_VAL];
bool used[MAX_VAL]; // Để reset cnt nhanh chóng
vector<int> touched_values;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int N;
    int64 X;
    cin >> N >> X;
    vector<int64> P(N);
    for(int i=0;i<N;i++) cin >> P[i];

    // Tính tổng tiền tố
    vector<int64> pref(N + 1, 0);
    for(int i=0;i<N;i++) pref[i+1] = pref[i] + P[i];

    vector<int> divisors;
    for(int64 d=1; d*d<=X; ++d) {
        if(X % d == 0) {
            if(d <= N) divisors.push_back((int)d);
            int64 d2 = X / d;
            if(d2 != d && d2 <= N) divisors.push_back((int)d2);
        }
    }

    int64 ans = 0;
    for(int k : divisors) {
        int64 target = X / k;
        if (target >= MAX_VAL) continue; // An toàn

        touched_values.clear();

        // Duyệt dãy con độ dài k
        for (int i = 0; i <= N - k; i++) {
            int64 sum = pref[i + k] - pref[i];
            if (sum < MAX_VAL) {
                if (!used[sum]) {
                    used[sum] = true;
                    touched_values.push_back(sum);
                }
                cnt[sum]++;
            }
        }

        // Đếm số cặp
        for (int val : touched_values) {
            int64 rem = target - val;
            if (rem < val) continue;
            if (rem < MAX_VAL && used[rem]) {
                if (rem == val) {
                    ans += (int64)cnt[val] * (cnt[val] - 1) / 2;
                } else {
                    ans += (int64)cnt[val] * cnt[rem];
                }
            }
        }

        // Reset mảng cnt để sử dụng cho lần lặp sau
        for (int val : touched_values) {
            cnt[val] = 0;
            used[val] = false;
        }
    }
    cout << ans;
    return 0;
}