/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author aryssoncf
 */

#include <bits/stdc++.h>


#include <iterator>


#include <string>
#include <stdexcept>

#ifndef SPCPPL_ASSERT
#ifdef SPCPPL_DEBUG
#define SPCPPL_ASSERT(condition) \
        if(!(condition)) { \
            throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
        }
#else
#define SPCPPL_ASSERT(condition)
#endif
#endif


/**
* Support decrementing and multi-passing, but not declared bidirectional(or even forward) because
* it's reference type is not a reference.
*
* It doesn't return reference because
* 1. Anyway it'll not satisfy requirement [forward.iterators]/6
*   If a and b are both dereferenceable, then a == b if and only if *a and
*   b are bound to the same object.
* 2. It'll not work with reverse_iterator that returns operator * of temporary which is temporary for this iterator
*
* Note, reverse_iterator is not guaranteed to work  now too since it works only with bidirectional iterators,
* but it's seems to work at least on my implementation.
*
* It's not really useful anywhere except iterating anyway.
*/
template<typename T>
class IntegerIterator {
public:
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = T *;
    using reference = T;
    using iterator_category = std::input_iterator_tag;

    explicit IntegerIterator(T value) : value(value) {

    }

    IntegerIterator &operator++() {
        ++value;
        return *this;
    }

    IntegerIterator operator++(int) {
        IntegerIterator copy = *this;
        ++value;
        return copy;
    }

    IntegerIterator &operator--() {
        --value;
        return *this;
    }

    IntegerIterator operator--(int) {
        IntegerIterator copy = *this;
        --value;
        return copy;
    }

    T operator*() const {
        return value;
    }

    bool operator==(IntegerIterator rhs) const {
        return value == rhs.value;
    }

    bool operator!=(IntegerIterator rhs) const {
        return !(*this == rhs);
    }

private:
    T value;
};

template<typename T>
class IntegerRange {
public:
    IntegerRange(T begin, T end) : begin_(begin), end_(end) {
        SPCPPL_ASSERT(begin <= end);
    }

    IntegerIterator<T> begin() const {
        return IntegerIterator<T>(begin_);
    }

    IntegerIterator<T> end() const {
        return IntegerIterator<T>(end_);
    }

private:
    T begin_;
    T end_;
};

template<typename T>
class ReversedIntegerRange {
    using IteratorType = std::reverse_iterator<IntegerIterator<T>>;
public:
    ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) {
        SPCPPL_ASSERT(begin >= end);
    }

    IteratorType begin() const {
        return IteratorType(IntegerIterator<T>(begin_));
    }

    IteratorType end() const {
        return IteratorType(IntegerIterator<T>(end_));
    }

private:
    T begin_;
    T end_;
};

template<typename T>
IntegerRange<T> range(T to) {
    return IntegerRange<T>(0, to);
}

template<typename T>
IntegerRange<T> range(T from, T to) {
    return IntegerRange<T>(from, to);
}

template<typename T>
IntegerRange<T> inclusiveRange(T to) {
    return IntegerRange<T>(0, to + 1);
}

template<typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
    return IntegerRange<T>(from, to + 1);
}

template<typename T>
ReversedIntegerRange<T> downrange(T from) {
    return ReversedIntegerRange<T>(from, 0);
}

template<typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
    return ReversedIntegerRange<T>(from, to);
}

template<typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
    return ReversedIntegerRange<T>(from + 1, 0);
}

template<typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
    return ReversedIntegerRange<T>(from + 1, to);
}


using namespace std;

class EMaxGCD {
    vector<int> A, B;

    vector<int> get_divs(int n) {
        vector<int> res;
        for (int i = 1; i * i <= n; i++) {
            if (n % i == 0) {
                res.push_back(i);
                if (n / i != i) {
                    res.push_back(n / i);
                }
            }
        }
        sort(res.begin(), res.end());
        return move(res);
    }

    long long f(int d) {
        int n = A.size();
        B.resize(n);
        for (int i: range(n)) {
            B[i] = A[i] % d;
        }
        sort(B.rbegin(), B.rend());
        long long res = 0;
        int pos = accumulate(B.begin(), B.end(), 0) / d;
        for (int i: range(n)) {
            if (i >= pos) {
                res += B[i];
            } else {
                res += d - B[i];
            }
        }
        return res / 2;
    }

public:
    void solve(std::istream &in, std::ostream &out) {
        int n, k;
        in >> n >> k;
        A.resize(n);
        for (int &x: A) {
            in >> x;
        }
        int sum = accumulate(A.begin(), A.end(), 0);
        vector<int> divs = get_divs(sum);
        int res = -1;
        for (int d: divs) {
            if (f(d) <= k) {
                res = d;
            }
        }
        out << res << "\n";
    }

    void setup() {}
};


int main() {
    std::ios_base::sync_with_stdio(false);
    EMaxGCD solver;
    solver.setup();
    std::istream &in(std::cin);
    std::ostream &out(std::cout);
    in.tie(nullptr);
    out << std::fixed;
    out.precision(20);
    solver.solve(in, out);
    return 0;
}


Measured memory_bytes: 256