#include <bits/stdc++.h>
using namespace std;
long long constexpr mod = 1000000007LL;
class llm {
  long long l;
  static std::unordered_map<long long, llm> inv;

 public:
  llm(long long m = 0LL) : l((m % mod >= 0) ? (m % mod) : (m % mod + mod)){};
  llm inverse() const {
    if (inv.find(l) == inv.end()) {
      llm x = pow(mod - 2);
      inv.emplace(l, x);
      return x;
    }
    return inv[l];
  }
  llm pow(long long i) const {
    if (i < 0) return inverse().pow(i);
    return pow(i, 1, l);
  }
  static llm pow(long long a, long long i, long long base = 1) {
    if (i == 0) return base;
    return pow(a * a % mod, i >> 1, base * ((i & 1) == 0 ? 1 : a) % mod);
  }
  llm operator=(llm m) {
    l = m.l;
    return *this;
  }
  llm operator<<(long long i) const { return pow(i); };
  llm operator>>(long long i) const { return pow(-i); }
  llm operator+(llm m) const { return llm(l + m.l); }
  llm operator+(int m) const { return llm(l + (m % mod)); }
  llm operator+(long m) const { return llm(l + (m % mod)); }
  llm operator+(long long m) const { return llm(l + (m % mod)); }
  llm operator-(llm m) const { return llm(l - m.l); }
  llm operator-(int m) const { return llm(l - (m % mod)); }
  llm operator-(long m) const { return llm(l - (m % mod)); }
  llm operator-(long long m) const { return llm(l - (m % mod)); }
  llm operator*(llm m) const { return llm(l * m.l); }
  llm operator*(int m) const { return llm(l * (m % mod)); }
  llm operator*(long m) const { return llm(l * (m % mod)); }
  llm operator*(long long m) const { return llm(l * (m % mod)); }
  llm operator/(llm m) const { return llm((*this) * m.inverse() % mod); }
  llm operator/(int m) const { return llm(l * llm(m).inverse()) % mod; }
  llm operator/(long m) const { return llm(l * llm(m).inverse()) % mod; }
  llm operator/(long long m) const { return llm(l * llm(m).inverse()) % mod; }
  long long operator++(void) { return l = (l + 1) % mod; }
  long long operator++(int) {
    long long tmp = l;
    ++(*this);
    return tmp;
  }
  long long operator--(void) { return l = (l - 1) % mod; }
  long long operator--(int) {
    long long tmp = l;
    --(*this);
    return tmp;
  }
  llm operator+(void) const { return llm(l); }
  llm operator-(void) const { return llm(-l); }
  template <typename T>
  llm operator+=(T m) {
    return *this = *this + m;
  }
  template <typename T>
  llm operator-=(T m) {
    return *this = *this - m;
  }
  template <typename T>
  llm operator*=(T m) {
    return *this = *this * m;
  }
  template <typename T>
  llm operator/=(T m) {
    return *this = *this / m;
  }
  operator long long() { return l; }
  friend std::istream &operator>>(std::istream &stream, llm &m);
};
std::unordered_map<long long, llm> llm::inv;
std::istream &operator>>(std::istream &stream, llm &m) {
  long long tmp;
  stream >> tmp;
  m.l = tmp % mod;
  return stream;
}
int main(void) {
  cin.tie(0);
  ios::sync_with_stdio(false);
  long long n;
  cin >> n;
  vector<llm> a(n);
  deque<long long> c1(60, 0);
  for (int i = 0; i < (n); ++i) {
    cin >> a[i];
    long long z = a[i];
    for (int j = 0; j < (60); ++j) {
      if (z & 1) {
        ++c1[j];
      }
      z >>= 1;
    }
  }
  llm result = 0;
  long long now = 1;
  for (long long i = 0; i < 60; ++i) {
    result += c1[i] * (n - c1[i]) * now;
    now *= 2;
  }
  cout << result;
  return 0;
}
