#include <bits/stdc++.h>

#define forn(i, n) for (int i = 0; i < int(n); i++)
#define nfor(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define fore(i, l, r) for (int i = int(l); i < int(r); i++)
#define correct(x, y, n, m) (0 <= (x) && (x) < (n) && 0 <= (y) && (y) < (m))
#define all(a) (a).begin(), (a).end()
#define sz(a) int((a).size())
#define pb(a) push_back(a)
#define mp(x, y) make_pair((x), (y))
#define x first
#define y second

using namespace std;

typedef long long li;
typedef double ld;
typedef pair<int, int> pt;

template<typename X> inline X abs(const X& a) { return a < 0? -a: a; }
template<typename X> inline X sqr(const X& a) { return a * a; }

template<typename A, typename B> inline ostream& operator<< (ostream& out, const pair<A, B>& p) { return out << "(" << p.x << ", " << p.y << ")"; }
template<typename T> inline ostream& operator<< (ostream& out, const vector<T>& a) { out << "["; forn(i, sz(a)) { if (i) out << ','; out << ' ' << a[i]; } return out << " ]"; }
template<typename T> inline ostream& operator<< (ostream& out, const set<T>& a) { return out << vector<T>(all(a)); }

inline ld gett() { return ld(clock()) / CLOCKS_PER_SEC; }

const int INF = int(1e9);
const li INF64 = li(1e18);
const ld EPS = 1e-9, PI = 3.1415926535897932384626433832795;

int n, k;
vector<int> a;

bool read() {
    if (!(cin >> n >> k)) return false;
    a.resize(n);
    forn(i, n) assert(scanf("%d", &a[i]) == 1);
    return true;
}

template<typename T, T MOD, T MAXV, int logn> class fftMod {
// Usage fftMod<int, 998244353, -1, 23> // g = 3
//       fftMod<int, 1004535809, -1, 19> fft; // g = 3
//       fftMod<int, 469762049, -1, 26> // g = 3
//       fftMod<li, 10000093151233, -1, 26> // g = 5
//       fftMod<li, 1000000523862017, -1, 26> // g = 3
//       fftMod<li, 1000000000949747713, -1, 26> // g = 2
//       fftMod<li, -1, li(1e13), 20>
// Here should be mul, add, inv, binPow functions for type T
    li mul(li a, li b, li mod) {
        li q = li(ld(a) * b / mod);
        li ans = (a * b - q * mod) % mod;
        return ans < 0 ? ans + mod : ans;
    }
    int mul(int a, int b, int mod) { return int(a * 1ll * b % mod); }
    T add(T a, T b, T mod) { return a + b >= mod ? (a + b - mod) : (a + b); }
    T sub(T a, T b, T mod) { return add(a, mod - b, mod); }
    T gcd(T a, T b, T& x, T& y) {
        if (!a) {
            x = 0, y = 1;
            return b;
        }
        T xx, yy, g = gcd(b % a, a, xx, yy);
        x = yy - b / a * xx;
        y = xx;
        return g;
    }
    T inv(T a, T mod) {
        T x, y;
        assert(gcd(a, mod, x, y) == 1);
        x %= mod;
        (x < 0) && (x += mod);
        return x;
    }
    T binPow(T a, T b, T mod) {
        T ans = 1;
        while (b) {
            if (b & 1) ans = mul(ans, a, mod);
            a = mul(a, a, mod);
            b >>= 1;
        }
        return ans;
    }

    static const int n = 1 << logn, N = n + 3;
    T p, g;
    void prepare() {
        T cs;
        if (MOD != -1) {
            assert(!((MOD - 1) & ((1 << logn) - 1)));
            p = MOD, cs = (p - 1) >> logn;
        } else { // implement isPrime and primitive root
            cs = MAXV / n + 1; // for this case
            //while (!isPrime(cs * n + 1)) cs++;
            p = cs * n + 1;
        }
        //g = primitiveRoot(p);
        g = 3;
        g = binPow(g, cs, p);
    }
    int get(int i) {
        int ans = 0;
        forn(j, logn) if (i & (1 << j)) ans |= 1 << (logn - 1 - j);
        return ans;
    }
    void fft(T *a, bool inverse) {
        static T tmp[N]; forn(i, n) tmp[i] = a[i];
        forn(i, n) a[i] = tmp[get(i)];
        assert(binPow(g, n, p) == 1);
        for (int i = 0; i < logn; i++) {
            T cg = binPow(g, 1 << (logn - (i + 1)), p);
            assert(binPow(cg, 1 << (i + 1), p) == 1);
            assert(binPow(cg, 1 << i, p) != 1);
            if (inverse) cg = inv(cg, p);
            for (int j = 0; j < n; j += (1 << (i + 1))) {
                T cur = 1;
                for (int k = 0; k < (1 << i); k++) {
                    T u = a[j + k], v = mul(a[j + (1 << i) + k], cur, p);
                    a[j + k] = add(u, v, p);
                    a[j + (1 << i) + k] = sub(u, v, p);
                    cur = mul(cur, cg, p);
                }
            }
        }
        if (inverse) forn(i, n) a[i] = mul(a[i], inv(n, p), p);
    }
public:
    void mul(T *a, T *b, T *ans) {
        static T _b[N];
        forn(i, n) ans[i] = a[i], _b[i] = b[i];
        prepare();
        fft(ans, false);
        fft(_b, false);
        forn(i, n) ans[i] = mul(ans[i], _b[i], p);
        fft(ans, true);
    }
    void binPow(T *a, int b) {
        prepare();
        fft(a, false);
        forn(i, n) a[i] = binPow(a[i], b, p);
        fft(a, true);
    }
};

const int LOGN = 20, N = (1 << LOGN) + 3;

fftMod<int, 998244353, -1, LOGN> fft;

void binPow(int* a, int b) {
    fft.binPow(a, b);
}

void solve() {
    static int ans[N];
    memset(ans, 0, sizeof(ans));
    forn(i, sz(a)) ans[a[i]] = 1;

    binPow(ans, k);

    bool f = true;
    forn(i, 1 << LOGN)
        if (ans[i]) {
            if (f) f = false;
            else putchar(' ');
            printf("%d", i);
        }
    puts("");
}

int main() {
#ifdef SU1
    assert(freopen("input.txt", "rt", stdin));
    //assert(freopen("output.txt", "wt", stdout));
#endif

    cout << setprecision(10) << fixed;
    cerr << setprecision(5) << fixed;

    while (read()) {
        ld stime = gett();
        solve();
        cerr << "Time: " << gett() - stime << endl;
        //break;
    }

    return 0;
}