#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
#define logn long
#define lnog long
#define lgon long
#define itn int
typedef pair<long long, long long> P;
const long long INF = 1000000000000006;
//省略系
string upper(string S) { // S の全文字を大文字にする. O(N)
    transform(S.begin(), S.end(), S.begin(), ::toupper);
    return S;
}
string lower(string S) { // S の全文字を小文字にする. O(N)
    transform(S.begin(), S.end(), S.begin(), ::tolower);
    return S;
}
long long len(string S) { // S の長さを取得（long long）. O(N)
    return (long long)S.size();
}
long long count_str(string S, char ch) { // S 内に文字 ch がいくつ存在するか. O(N)
    long long ans = 0;
    for (long long i = 0; i < len(S); i++) {
        ans += (S.at(i) == ch);
    }
    return ans;
}
vector<string> split(string S, char ch) { //特定の文字 ch で S を分ける. O(N)
    string T;
    vector<string>A;
    for (long long i = 0; i < len(S); i++) {
        if (S[i] != ch) T.push_back(S[i]);
        else {
            A.push_back(T);
            T.clear();
        }
    }
    if (!T.empty()) A.push_back(T);
    return A;
}
template <typename T>
vector<T> rep(vector<T>& A, long long N) {
    vector<T> B;
    for (long long i = 0; i < N; i++) {
        for (long long j = 0; j < A.size(); j++) {
            B.push_back(A[j]);
        }
    }
    return B;
}
template <typename T>
long long count_arr(vector<T>& A, T key) {
    long long ans = 0;
    for (long long i = 0; i < A.size(); i++) {
        ans += (A.at(i) == key);
    }
    return ans;
}
template <typename Q>
string join(vector<Q>& A, char ch) {
    string S;
    for (long long i = 0; i < A.size(); i++) {
        string T = to_string(A.at(i));
        long long j = 0;
        while (j < T.size()) {
            S.push_back(T[j]);
            j++;
        }
        if (i != A.size() - 1) S.push_back(ch);
    }
    return S;
}
template<typename T>
vector<T> sorted(vector<T>& A) {
    sort(A.begin(), A.end());
    return A;
}
template<typename T>
vector<T> reversed(vector<T>& A) {
    reverse(A.begin(), A.end());
    return A;
}
template<typename T>
long long max_arr(vector<T>& A) {
    long long num = -10000000000000007;
    for (long long i = 0; i < A.size(); i++) {
        if (A[i] > num) num = A[i];
    }
    return num;
}
template<typename T>
long long min_arr(vector<T>& A) {
    long long num = 10000000000000007;
    for (long long i = 0; i < A.size(); i++) {
        if (A[i] < num) num = A[i];
    }
    return num;
}
struct UnionFind {
    vector<long long> par, siz;

    //初期化
    UnionFind(long long N) : par(N, -1), siz(N, 1) {}

    //根を求める
    long long root(long long x) {
        if (par[x] == -1) return x; //x自身が根である
        else return par[x] = root(par[x]);
    }

    //x と y が同じグループに属するかどうか
    bool same(long long x, long long y) {
        return root(x) == root(y);
    }

    //x を含むグループと y を含むグループを併合
    bool unite(long long x, long long y) {
        //x, y をそれぞれ根まで移動
        x = root(x); y = root(y);

        //既に x と y が同グループに属するなら false
        if (x == y) return false;

        //union by size
        if (siz[x] < siz[y]) swap(x, y);

        //y を x の子にする
        par[y] = x;
        siz[x] += siz[y];
        return true;
    }

    //x を含むグループのサイズ
    long long size(long long x) {
        return siz[root(x)];
    }
    //連結成分の個数をカウント
    long long count() {
        long long ans = 0;
        for (long long i = 0; i < (long long)par.size(); i++) {
            ans += (root(i) == i);
        }
        return ans;
    }
};
template <typename T>
struct RMQ {
    const T INF = 2147483647;
    int N; //number of leaves
    vector<T> dat; //perfect binary tree

    RMQ(int n_) : N(), dat(n_ * 4, INF) { //The number of leaves can be displayed by the formula, 2 ^ x.
        int x = 1;
        while (n_ > x) {
            x *= 2;
        }
        N = x;
    }

    void update(long long i, T x) {
        i += N - 1;
        dat.at(i) = x;
        while (i > 0) {
            i = (i - 1) / 2; //parent
            dat.at(i) = min(dat.at(i * 2 + 1), dat.at(i * 2 + 2));
        }
    }

    //the minimum element of [a, b)
    T query(long long a, long long b) {
        return query_sub(a, b, 0, 0, N);
    }
    T query_sub(long long a, long long b, long long k, long long l, long long r) {
        if (r <= a || b <= l) {
            return INF;
        }
        else if (a <= l && r <= b) {
            return dat.at(k);
        }
        else {
            T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
            T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
            return min(vl, vr);
        }
    }
};
template <typename T>
void input_arr(vector<T>& A, long long N) {
    for (long long i = 0; i < N; i++) {
        cin >> A[i];
    }
}
template <typename T>
void output_arr(vector<T>& A, long long N) {
    for (long long i = 0; i < N; i++) {
        cout << A[i];
        if (i != N - 1) cout << ' ';
    }
    cout << endl;
}
long long GCD(long long A, long long B) { return(B == 0 ? A : GCD(B, A % B)); }
long long LCM(long long A, long long B) { return A / GCD(A, B) * B; }
template <typename T>
bool find(vector<T>& A, T key) {
    for (long long i = 0; i < A.size(); i++) {
        if (A[i] == key) return true;
    }
    return false;
}
template <typename T>
long long elements(vector<T>& A) {
    sort(A.begin(), A.end());
    long long ans = 1;
    for (long long i = 1; i < A.size(); i++) {
        if (A[i] != A[i - 1]) ans++;
    }
    return ans;
}
int main() {
    long long N, K; cin >> N >> K;
    vector<long long>A(N); input_arr(A, N);
    vector<long long>num;
    for (long long i = 0; i < (1 << N); i++) {
        long long sum = 0, number = 0, times = 1;
        for (long long j = 0; j < N; j++) {
            if (i & (1 << j)) {
                sum += A[j];
                times *= A[j];
                number++;
            }
            if (number >= K) {
                num.push_back(sum);
                num.push_back(times);
            }
        }
    }
    cout << elements(num) << endl;
}