import sys


# 统计一个正整数中因子 2 和因子 5 的个数
def get_factor_count(x):
    cnt2 = 0
    cnt5 = 0

    # 统计因子 2 的个数
    while x % 2 == 0:
        cnt2 += 1
        x //= 2

    # 统计因子 5 的个数
    while x % 5 == 0:
        cnt5 += 1
        x //= 5

    return cnt2, cnt5


# 统计满足条件的子数组个数
def count_divisible_subarrays(n, k, arr):
    twos = [0] * n
    fives = [0] * n

    # 预处理每个元素中因子 2 和因子 5 的个数
    for i in range(n):
        twos[i], fives[i] = get_factor_count(arr[i])

    ans = 0
    sum2 = 0
    sum5 = 0
    r = 0

    # 枚举左端点
    for l in range(n):
        # 扩展右端点，直到当前窗口满足条件
        while r < n and (sum2 < k or sum5 < k):
            sum2 += twos[r]
            sum5 += fives[r]
            r += 1

        # 如果当前窗口满足条件
        # 此时窗口是 [l, r-1]
        # 那么右端点取 r-1 到 n-1 都合法
        if sum2 >= k and sum5 >= k:
            ans += n - r + 1

        # 左端点右移前，移除当前左端点的贡献
        sum2 -= twos[l]
        sum5 -= fives[l]

    return ans


def main():
    data = list(map(int, sys.stdin.read().split()))
    n, k = data[0], data[1]
    arr = data[2:2 + n]

    print(count_divisible_subarrays(n, k, arr))


if __name__ == "__main__":
    main()

#include <iostream>
#include <vector>
using namespace std;

// 统计一个正整数中因子 2 和因子 5 的个数
pair<int, int> getFactorCount(int x) {
    int cnt2 = 0;
    int cnt5 = 0;

    // 统计因子 2 的个数
    while (x % 2 == 0) {
        cnt2++;
        x /= 2;
    }

    // 统计因子 5 的个数
    while (x % 5 == 0) {
        cnt5++;
        x /= 5;
    }

    return {cnt2, cnt5};
}

// 统计满足条件的子数组个数
long long countDivisibleSubarrays(int n, long long k, const vector<int>& arr) {
    vector<int> twos(n), fives(n);

    // 预处理每个元素中因子 2 和因子 5 的个数
    for (int i = 0; i < n; i++) {
        pair<int, int> res = getFactorCount(arr[i]);
        twos[i] = res.first;
        fives[i] = res.second;
    }

    long long ans = 0;
    long long sum2 = 0;
    long long sum5 = 0;
    int r = 0;

    // 枚举左端点
    for (int l = 0; l < n; l++) {
        // 扩展右端点，直到当前窗口满足条件
        while (r < n && (sum2 < k || sum5 < k)) {
            sum2 += twos[r];
            sum5 += fives[r];
            r++;
        }

        // 如果当前窗口满足条件
        // 此时窗口是 [l, r-1]
        // 那么右端点从 r-1 到 n-1 都满足条件
        if (sum2 >= k && sum5 >= k) {
            ans += n - r + 1;
        }

        // 左端点右移前，移除当前左端点的贡献
        sum2 -= twos[l];
        sum5 -= fives[l];
    }

    return ans;
}

int main() {
    int n;
    long long k;
    cin >> n >> k;

    vector<int> arr(n);
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }

    cout << countDivisibleSubarrays(n, k, arr) << '\n';
    return 0;
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class Main {

    // 统计一个正整数中因子 2 和因子 5 的个数
    public static int[] getFactorCount(int x) {
        int cnt2 = 0;
        int cnt5 = 0;

        // 统计因子 2 的个数
        while (x % 2 == 0) {
            cnt2++;
            x /= 2;
        }

        // 统计因子 5 的个数
        while (x % 5 == 0) {
            cnt5++;
            x /= 5;
        }

        return new int[]{cnt2, cnt5};
    }

    // 统计满足条件的子数组个数
    public static long countDivisibleSubarrays(int n, long k, int[] arr) {
        int[] twos = new int[n];
        int[] fives = new int[n];

        // 预处理每个元素中因子 2 和因子 5 的个数
        for (int i = 0; i < n; i++) {
            int[] res = getFactorCount(arr[i]);
            twos[i] = res[0];
            fives[i] = res[1];
        }

        long ans = 0;
        long sum2 = 0;
        long sum5 = 0;
        int r = 0;

        // 枚举左端点
        for (int l = 0; l < n; l++) {
            // 扩展右端点，直到当前窗口满足条件
            while (r < n && (sum2 < k || sum5 < k)) {
                sum2 += twos[r];
                sum5 += fives[r];
                r++;
            }

            // 如果当前窗口满足条件
            // 此时窗口为 [l, r-1]
            // 那么右端点从 r-1 到 n-1 都满足条件
            if (sum2 >= k && sum5 >= k) {
                ans += n - r + 1;
            }

            // 左端点右移前，移除当前左端点的贡献
            sum2 -= twos[l];
            sum5 -= fives[l];
        }

        return ans;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int n = Integer.parseInt(st.nextToken());
        long k = Long.parseLong(st.nextToken());

        int[] arr = new int[n];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        System.out.println(countDivisibleSubarrays(n, k, arr));
    }
}