description: PizzaForces is Petya's favorite pizzeria. PizzaForces makes and sells pizzas of three sizes: small pizzas consist of 6 slices, medium ones consist of 8 slices, and large pizzas consist of 10 slices each. Baking them takes 15, 20 and 25 minutes, respectively.
  
  Petya's birthday is today, and n of his friends will come, so he decided to make an order from his favorite pizzeria. Petya wants to order so much pizza that each of his friends gets at least one slice of pizza. The cooking time of the order is the total baking time of all the pizzas in the order.
  
  Your task is to determine the minimum number of minutes that is needed to make pizzas containing at least n slices in total. For example: 
  
    * if 12 friends come to Petya's birthday, he has to order pizzas containing at least 12 slices in total. He can order two small pizzas, containing exactly 12 slices, and the time to bake them is 30 minutes; 
    * if 15 friends come to Petya's birthday, he has to order pizzas containing at least 15 slices in total. He can order a small pizza and a large pizza, containing 16 slices, and the time to bake them is 40 minutes; 
    * if 300 friends come to Petya's birthday, he has to order pizzas containing at least 300 slices in total. He can order 15 small pizzas, 10 medium pizzas and 13 large pizzas, in total they contain 15 ⋅ 6 + 10 ⋅ 8 + 13 ⋅ 10 = 300 slices, and the total time to bake them is 15 ⋅ 15 + 10 ⋅ 20 + 13 ⋅ 25 = 750 minutes; 
    * if only one friend comes to Petya's birthday, he can order a small pizza, and the time to bake it is 15 minutes. 
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.
  
  Each testcase consists of a single line that contains a single integer n (1 ≤ n ≤ 10^{16}) — the number of Petya's friends.
  
  Output
  
  For each testcase, print one integer — the minimum number of minutes that is needed to bake pizzas containing at least n slices in total.
  
  Example
  
  Input
  
  
  6
  12
  15
  300
  1
  9999999999999999
  3
  
  
  Output
  
  
  30
  40
  750
  15
  25000000000000000
  15
solution: #include <bits/stdc++.h>
  using namespace std;
  mt19937_64 rang(
      chrono::high_resolution_clock::now().time_since_epoch().count());
  int rng(int lim) {
    uniform_int_distribution<int> uid(0, lim - 1);
    return uid(rang);
  }
  long long gcd(long long a, long long b) {
    if (max(a, b) % min(a, b) == 0) {
      return min(a, b);
    }
    return gcd(max(a, b) % min(a, b), min(a, b));
  }
  long long p = 1000000007;
  void SieveOfEratosthenes(long long l, long long n, vector<long long> &prim) {
    bool prime[n + 1];
    memset(prime, true, sizeof(prime));
    for (int p = 2; p * p <= n; p++) {
      if (prime[p] == true) {
        for (long i = p * p; i <= n; i += p) prime[i] = false;
      }
    }
    long long sum = 0;
    for (int p = 2; p <= n; p++)
      if (prime[p] && p >= l) prim.push_back(p);
  }
  long long power(long long x, long long y) {
    long long res = 1;
    x = x % p;
    if (x == 0) return 0;
    while (y > 0) {
      if (y & 1) res = (res * x) % p;
      y = y >> 1;
      x = (x * x) % p;
    }
    return res;
  }
  void printit(vector<int> &a) {
    for (auto it : a) cout << it << " ";
    cout << endl;
  }
  bool cmp_pair(const pair<int, int> &a, const pair<int, int> &b) {
    if (a.second < b.second)
      return true;
    else if (a.second > b.second)
      return false;
    else {
      return a.first < b.first;
    }
  }
  int toDigit(char ch) { return (ch - '0'); }
  int countSetBits(long long unsigned n) {
    if (n == 0)
      return 0;
    else
      return (n & 1) + countSetBits(n >> 1);
  }
  long long unsigned fact(long long unsigned a) {
    long long t = 1;
    long long unsigned ans = 1;
    while (t <= a) ans *= t, ans %= p, t++;
    return ans;
  }
  set<long long> digits(long long n) {
    set<long long> s;
    while (n) {
      if (n % 10) s.insert(n % 10);
      n /= 10;
    }
    return s;
  }
  bool is_prime(long long n) {
    if (n == 1) {
      return false;
    }
    long long i = 2;
    while (i * i <= n) {
      if (n % i == 0) {
        return false;
      }
      i += 1;
    }
    return true;
  }
  long long rsum(vector<long long> &pref, long long i, long long j) {
    if (j >= pref.size()) return pref[pref.size() - 1];
    if (i > j) return 0;
    if (i == 0) return pref[j];
    return pref[j] - pref[i - 1];
  }
  bool isPowerOfTwo(long long n) {
    if (n == 0) return 0;
    while (n != 1) {
      if (n % 2 != 0) return 0;
      n = n / 2;
    }
    return 1;
  }
  bool isPerfectSquare(long double x) {
    if (x >= 0) {
      long long sr = sqrt(x);
      return (sr * sr == x);
    }
    return false;
  }
  bool found = false;
  struct comp {
    bool operator()(const vector<int> &lhs, const vector<int> &rhs) {
      return lhs[1] < rhs[1];
    }
  };
  unsigned long long power(unsigned long long x, int y, int p) {
    unsigned long long res = 1;
    x = x % p;
    while (y > 0) {
      if (y & 1) res = (res * x) % p;
      y = y >> 1;
      x = (x * x) % p;
    }
    return res;
  }
  unsigned long long modInverse(unsigned long long n, int p) {
    return power(n, p - 2, p);
  }
  unsigned long long nCrModPFermat(unsigned long long n, int r, int p) {
    if (n < r) return 0;
    if (r == 0) return 1;
    unsigned long long fac[n + 1];
    fac[0] = 1;
    for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
    return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
           p;
  }
  long long range_sum(vector<vector<long long>> &b, int x, int y) {
    int sum = 0;
    for (; x > 0; x -= x & -x) {
      for (; y > 0; y -= y & -y) {
        sum += b[x][y];
      }
    }
    return sum;
  }
  const long long mxm = 1e8;
  const long long mxd = 100001;
  bool c1(vector<long long> &a, vector<long long> &b) { return a[0] > b[0]; }
  bool c2(vector<long long> &a, vector<long long> &b) { return a[1] > b[2]; }
  vector<int> tree[100001];
  int depth[100001];
  int parent[100001][19];
  void dfs(int cur, int prev) {
    depth[cur] = depth[prev] + 1;
    parent[cur][0] = prev;
    for (int i = 0; i < tree[cur].size(); i++) {
      if (tree[cur][i] != prev) dfs(tree[cur][i], cur);
    }
  }
  void precomputeSparseMatrix(int n) {
    for (int i = 1; i < 19; i++) {
      for (int node = 1; node <= n; node++) {
        if (parent[node][i - 1] != -1)
          parent[node][i] = parent[parent[node][i - 1]][i - 1];
      }
    }
  }
  int lca(int u, int v) {
    if (depth[v] < depth[u]) swap(u, v);
    int diff = depth[v] - depth[u];
    for (int i = 0; i < 19; i++)
      if ((diff >> i) & 1) v = parent[v][i];
    if (u == v) return u;
    for (int i = 19 - 1; i >= 0; i--)
      if (parent[u][i] != parent[v][i]) {
        u = parent[u][i];
        v = parent[v][i];
      }
    return parent[u][0];
  }
  void addEdge(int u, int v) {
    tree[u].push_back(v);
    tree[v].push_back(u);
  }
  int tas = 0;
  void rec(vector<vector<char>> &a, int i, int j, int k, int cur) {
    if (cur == k) {
      tas++;
      return;
    }
    if (j < a[0].size() - 1 && a[i][j + 1] == '.') {
      rec(a, i, j + 1, k, cur + 1);
    }
    if (i < a.size() - 1 && a[i + 1][j] == '.') {
      rec(a, i + 1, j, k, cur + 1);
    }
  }
  int rec(int sum, int i, int j) {
    if (i == 0) return sum == j;
    return rec(sum + 1, i - 1, j) + rec(sum - 1, i - 1, j);
  }
  int kk;
  long long cal(long long n) {
    long long r = n % 10;
    if (r == 0) {
      return (n / 10) * 25;
    }
    if (n <= 6) {
      return 15;
    } else if (n <= 8) {
      return 20;
    } else if (n < 10) {
      return 25;
    }
    long long ans;
    if (r <= 2) {
      n -= r;
      n -= 10;
      ans = (n / 10) * 25 + 2 * 15;
    } else if (r <= 4) {
      n -= r;
      n -= 10;
      ans = (n / 10) * 25 + 1 * 15 + 1 * 20;
    } else if (r <= 6) {
      n -= r;
      n -= 10;
      ans = (n / 10) * 25 + 2 * 20;
    } else if (r <= 8) {
      n -= r;
      n -= 10;
      ans = (n / 10) * 25 + 1 * 20 + 1 * 25;
    } else {
      ans = (n / 10 + 1) * 25;
    }
    return ans;
  }
  void solve() {
    long long d, r, j, l = 0, w = 1, x, h = 0, x1 = 1e12, x2 = 0, y1 = 0, y2, x3,
                       c, x4, y3, y4, ans1 = 0, y, n, D, I, second, V, first, o,
                       m, i = 0, temp = 1e18, ans = -1e10, negi = 0, k = 0, rate,
                       pum = 0, nsum = 0;
    long long sum = 0, l1 = 1e5, l2 = -1e5, l3;
    cin >> n;
    ans = cal(n);
    cout << ans << '\n';
  }
  int main() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());
    int t;
    t = 1;
    cin >> t;
    int tt = t;
    for (int tt = 0; tt < t; tt++) {
      solve();
    }
  }
  