Problem p02608 (C++) — buggy submission, verdict: Time Limit Exceeded

#pragma region template
#ifdef ONLINE_JUDGE
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC diagnostic ignored "-Wunused-result"
#endif

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define last(a) *(a).rbegin()
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define brep(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; i++)
#define rrep(i, n) for (int i = (n)-1, now = 0; i >= 0; i--, now++)
#define xrep(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define yes(n) cout << ((n) ? YES : NO) << '\\n'
#define co(n) cout << n << '\\n'
#define cco(...) prints(__VA_ARGS__)
#define fo(n) printf("%.15lf\\n", (n))
#define fout cout << fixed << setprecision(15)
#define Sort(v) sort(all(v))
#define rSort(v) sort(all(v), greater<typeof(v[0])>())
#define Rev(v) reverse(all(v))
#define Unique(v) (v).erase(unique(all(v)), (v).end())
#define in_range(x, a, b) ((a) <= (x) && (x) < (b))
#define in_area(x, y, a, b) (0 <= (x) && 0 <= (y) && (x) < (a) && (y) < (b))
#define br puts("")
#define eb emplace_back
#define fi first
#define se second

#ifdef ONLINE_JUDGE
#define here()
#define cprint(vec)
#define com(msg)
#define obs(...)
#define local(x)
#define alter(x, y) y
#else
#define here() cerr << __func__ << '/' << __LINE__ << ": passed\\n"
#define cprint(vec) dmp(vec)
#define com(msg) cerr << "{ " << msg << " }\\n"
#define obs(...) observe(#__VA_ARGS__, __VA_ARGS__)
#define local(x) x
#define alter(x, y) x
#endif

using namespace std;
using ll = long long;
using ld = long double;
using pt = pair<int, int>;
using ull = unsigned long long;
using vbl = vector<bool>;
using dqbl = deque<bool>;
using vint = vector<int>;
using vll = vector<long long>;
using vpt = vector<pair<int, int>>;
using vdbl = vector<double>;
using vstr = vector<string>;
using vvbl = vector<vector<bool>>;
using vdqbl = vector<deque<bool>>;
using vvint = vector<vector<int>>;
using vvll = vector<vector<long long>>;

template <class T> using uset = unordered_set<T>;
template <class S, class T> using umap = unordered_map<S, T>;

constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-9;
constexpr long double LEPS = 1e-18;
constexpr int dy4[] = {1, 0, -1, 0};
constexpr int dx4[] = {0, 1, 0, -1};
constexpr int dy8[] = {1, 1, 1, 0, -1, -1, -1, 0};
constexpr int dx8[] = {-1, 0, 1, 1, 1, 0, -1, -1};

// --- functions which take 1 argument --- //
template <class T> inline int sgn(const T &x) { return (x > 0) - (x < 0); }
template <class S, class T> inline int digit(S x, const T &b = 10) {
  int r = 1;
  while ((x /= b) >= 1)
    r++;
  return r;
}
template <class T> inline double degToRad(const T &a) {
  return a / 180.0 * M_PI;
}
template <class T> inline double radToDeg(const T &a) {
  return a / M_PI * 180.0;
}
template <class T> inline long long factorial(const T &n) {
  if (n == 0)
    return 1;
  ll r = 1;
  brep(i, 2, n) r *= i;
  return r;
}
template <class T> inline bool isPrime(const T &n) {
  T i = 2;
  while (i * i <= n) {
    if (n % i == 0 && n != i)
      return 0;
    i++;
  }
  return 1;
}
template <class T> inline map<T, T> factorize(T n) {
  map<T, T> r;
  for (T i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      r[i]++;
      n /= i;
    }
  }
  if (n != 1)
    r[n] = 1;
  return r;
}
template <class T> inline vector<T> divisor(const T &n) {
  vector<T> r;
  for (T i = 1; i * i <= n; i++) {
    if (!(n % i)) {
      r.eb(i);
      if (i * i != n)
        r.eb(n / i);
    }
  }
  return r;
}

// --- functions which take more than 1 argument --- //
template <class S, class T> inline bool chmax(S &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class S, class T> inline bool chmin(S &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class S, class T> inline long long bpow(S m, T n) {
  ll r = 1;
  while (n > 0) {
    if (n & 1)
      r *= m;
    m *= m;
    n /= 2;
  }
  return r;
}
template <class S, class T>
inline common_type<S, T> nPr(const S &n, const T &k) {
  if (n < k || n < 0 || k < 0)
    return 0;
  T r = 1;
  brep(i, n - k + 1, n) r *= i;
  return r;
}
template <class S, class T> inline common_type<S, T> nCr(const S &n, T k) {
  if (n < k || n < 0 || k < 0)
    return 0;
  T r = 1;
  k = min(k, n - k);
  brep(i, n - k + 1, n) r *= i;
  return r / factorial(k);
}
template <class T> inline void prints(const T &v) { cout << v << '\\n'; }
template <class S, class... T> inline void prints(const S &v, const T &...w) {
  cout << v << ' ';
  prints(w...);
}

// --- functions which take vector/deque as argument --- //
template <class T> inline void printD(const vector<T> &v, string d) {
  rep(i, sz(v) - 1) cout << v[i] << d;
  cout << *v.rbegin() << '\\n';
}
template <class T> inline void printD(const vector<vector<T>> &v, string d) {
  for (const auto &x : v)
    printD(x, d);
}
template <class T> inline bool in(const T &k, const vector<T> &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const int &k, const vector<ll> &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const ll &k, const vector<int> &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const char &k, const string &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const char *&k, const vector<string> &v) {
  return find(all(v), k) != v.end();
}
template <class T> inline double abs(const vector<T> &v) {
  return sqrt(reduce(all(v), 0.0, [](T s, T v) { return s += v * v; }));
}
template <class T> inline T min(const vector<T> &v) {
  return *min_element(all(v));
}
template <class T> inline T max(const vector<T> &v) {
  return *max_element(all(v));
}
template <class T> inline T sum(const vector<T> &v) {
  return reduce(all(v), (T)0);
}
template <class T> inline T gcd(const vector<T> &v) {
  T r = v[0];
  brep(i, 1, sz(v) - 1) r = gcd(r, v[i]);
  return r;
}
template <class T> inline T lcm(const vector<T> &v) {
  T r = v[0];
  brep(i, 1, sz(v) - 1) r = lcm(r, v[i]);
  return r;
}
template <class T> inline T vectorAdd(const T &u, const T &v) {
  T r(u.size());
  rep(i, u.size()) r[i] = u[i] + v[i];
  return r;
}
template <class T> inline T vectorSubtract(const T &u, const T &v) {
  T r(u.size());
  rep(i, u.size()) r[i] = u[i] - v[i];
  return r;
}
template <class T> inline T vectorMultiply(const T &u, const T &v) {
  T r(u.size());
  rep(i, u.size()) r[i] = u[i] * v[i];
  return r;
}
template <class T>
inline T dotProduct(const deque<bool> &u, const vector<T> &v) {
  T r = 0;
  rep(i, u.size()) if (u[i]) r += v[i];
  return r;
}
template <class S, class T>
inline common_type<S, T> dotProduct(const vector<S> &u, const vector<T> &v) {
  T r = 0;
  rep(i, u.size()) r += u[i] * v[i];
  return r;
}
template <class S, class T> inline void sortBySecond(vector<pair<S, T>> &v) {
  sort(all(v), [](auto L, auto R) { return L.second < R.second; });
}

// --- functions which take set/map as argument --- //
template <class T> inline T min(const set<T> &v) {
  return *min_element(all(v));
}
template <class T> inline T min(const uset<T> &v) {
  return *min_element(all(v));
}
template <class T> inline T max(const set<T> &v) {
  return *max_element(all(v));
}
template <class T> inline T max(const uset<T> &v) {
  return *max_element(all(v));
}
template <class T> inline T sum(const set<T> &v) {
  return reduce(all(v), (T)0);
}
template <class T> inline T sum(const uset<T> &v) {
  return reduce(all(v), (T)0);
}
template <class T> inline T gcd(const set<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : gcd(r, x);
  return r;
}
template <class T> inline T gcd(const uset<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : gcd(r, x);
  return r;
}
template <class T> inline T lcm(const set<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : lcm(r, x);
  return r;
}
template <class T> inline T lcm(const uset<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : lcm(r, x);
  return r;
}
template <class T> inline bool in(const T &k, const set<T> &v) {
  return find(all(v), k) != v.end();
}
template <class T> inline bool in(const T &k, const uset<T> &v) {
  return find(all(v), k) != v.end();
}
template <class S, class T> inline pair<S, T> min(const map<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmin(r.se, p.se))
      r = p;
  return r;
}
template <class S, class T> inline pair<S, T> min(const umap<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmin(r.se, p.se))
      r = p;
  return r;
}
template <class S, class T> inline pair<S, T> max(const map<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmax(r.se, p.se))
      r = p;
  return r;
}
template <class S, class T> inline pair<S, T> max(const umap<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmax(r.se, p.se))
      r = p;
  return r;
}

// --- functions for debugging --- //
template <class T> inline void observe(const char *n, T &&v) {
  cerr << n << ": " << v << '\\n';
}
template <class S, class... T>
inline void observe(const char *n, S &&v, T &&...w) {
  const char *c = strchr(n + 1, ',');
  cerr.write(n, c - n) << ": " << v << " |";
  observe(c + 1, w...);
}
template <class T> inline void dmp(const vector<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class T> inline void dmp(const deque<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class T> inline void dmp(const set<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class T> inline void dmp(const uset<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class P> inline void dmp(const P &p) {
  cerr << "{ " << p.first << ' ' << p.second << " } ";
}
template <class T> inline void dmp(const vector<vector<T>> &v) {
  for (const auto &x : v)
    dmp<T>(x);
}
template <class T> inline void dmp(const vector<deque<T>> &v) {
  for (const auto &x : v)
    dmp<T>(x);
}
template <class S, class T> inline void dmp(const map<S, T> &m) {
  cerr << "[ ";
  for (const auto &p : m)
    cerr << "{ " << p.first << ", " << p.second << " } ";
  cerr << "]\\n";
}
template <class S, class T> inline void dmp(const umap<S, T> &m) {
  cerr << "[ ";
  for (const auto &p : m)
    cerr << "{ " << p.first << ", " << p.second << " } ";
  cerr << "]\\n";
}
template <class S, class T> inline void dmp(const vector<pair<S, T>> &v) {
  cerr << "[ ";
  for (const auto &x : v)
    dmp<pair<S, T>>(x);
  cerr << " ]\\n";
}
#pragma endregion template

inline int isSquare(const int &n) {
  int ret = 0;
  while (1) {
    ret++;
    if (ret * ret == n)
      return ret;
    if (ret * ret > n)
      return -1;
  }
}

void solve(int N) {
  xrep(i, N) {
    vector<vector<int>> checked;
    int ret = 0;
    int Limit = sqrt(i);
    xrep(x, Limit) {
      brep(y, x, Limit) {
        int ex = 4 * i - 3 * x * x - 3 * y * y - 2 * x * y;
        if (ex < 0)
          break;
        int k = isSquare(ex);
        if (k == -1)
          continue;
        int z = k - x - y;
        // ret += ((z & 1) == 0 && z >= 2);

        if ((z & 1) == 0 && (z >>= 1) >= 1) {
          vint A{x, y, z};
          Sort(A);
          Unique(A);
          if (in(A, checked))
            break;
          obs(i, x, y, z);
          cprint(A);
          // ret++;
          ret += vint{0, 1, 3, 6}[sz(A)];
          checked.eb(A);
          // goto pr;
        }
      }
    }
    // pr:
    printf("%d\\n", ret);
  }
}

int main() {
  int N;
  scanf("%d", &N);
  solve(N);
  return 0;
}


Error: TLE

Fixed submission:

#pragma region template
#ifdef ONLINE_JUDGE
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC diagnostic ignored "-Wunused-result"
#endif

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define last(a) *(a).rbegin()
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define brep(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; i++)
#define rrep(i, n) for (int i = (n)-1, now = 0; i >= 0; i--, now++)
#define xrep(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define yes(n) cout << ((n) ? YES : NO) << '\\n'
#define co(n) cout << n << '\\n'
#define cco(...) prints(__VA_ARGS__)
#define fo(n) printf("%.15lf\\n", (n))
#define fout cout << fixed << setprecision(15)
#define Sort(v) sort(all(v))
#define rSort(v) sort(all(v), greater<typeof(v[0])>())
#define Rev(v) reverse(all(v))
#define Unique(v) (v).erase(unique(all(v)), (v).end())
#define in_range(x, a, b) ((a) <= (x) && (x) < (b))
#define in_area(x, y, a, b) (0 <= (x) && 0 <= (y) && (x) < (a) && (y) < (b))
#define br puts("")
#define eb emplace_back
#define fi first
#define se second

#ifdef ONLINE_JUDGE
#define here()
#define cprint(vec)
#define com(msg)
#define obs(...)
#define local(x)
#define alter(x, y) y
#else
#define here() cerr << __func__ << '/' << __LINE__ << ": passed\\n"
#define cprint(vec) dmp(vec)
#define com(msg) cerr << "{ " << msg << " }\\n"
#define obs(...) observe(#__VA_ARGS__, __VA_ARGS__)
#define local(x) x
#define alter(x, y) x
#endif

using namespace std;
using ll = long long;
using ld = long double;
using pt = pair<int, int>;
using ull = unsigned long long;
using vbl = vector<bool>;
using dqbl = deque<bool>;
using vint = vector<int>;
using vll = vector<long long>;
using vpt = vector<pair<int, int>>;
using vdbl = vector<double>;
using vstr = vector<string>;
using vvbl = vector<vector<bool>>;
using vdqbl = vector<deque<bool>>;
using vvint = vector<vector<int>>;
using vvll = vector<vector<long long>>;

template <class T> using uset = unordered_set<T>;
template <class S, class T> using umap = unordered_map<S, T>;

constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-9;
constexpr long double LEPS = 1e-18;
constexpr int dy4[] = {1, 0, -1, 0};
constexpr int dx4[] = {0, 1, 0, -1};
constexpr int dy8[] = {1, 1, 1, 0, -1, -1, -1, 0};
constexpr int dx8[] = {-1, 0, 1, 1, 1, 0, -1, -1};

// --- functions which take 1 argument --- //
template <class T> inline int sgn(const T &x) { return (x > 0) - (x < 0); }
template <class S, class T> inline int digit(S x, const T &b = 10) {
  int r = 1;
  while ((x /= b) >= 1)
    r++;
  return r;
}
template <class T> inline double degToRad(const T &a) {
  return a / 180.0 * M_PI;
}
template <class T> inline double radToDeg(const T &a) {
  return a / M_PI * 180.0;
}
template <class T> inline long long factorial(const T &n) {
  if (n == 0)
    return 1;
  ll r = 1;
  brep(i, 2, n) r *= i;
  return r;
}
template <class T> inline bool isPrime(const T &n) {
  T i = 2;
  while (i * i <= n) {
    if (n % i == 0 && n != i)
      return 0;
    i++;
  }
  return 1;
}
template <class T> inline map<T, T> factorize(T n) {
  map<T, T> r;
  for (T i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      r[i]++;
      n /= i;
    }
  }
  if (n != 1)
    r[n] = 1;
  return r;
}
template <class T> inline vector<T> divisor(const T &n) {
  vector<T> r;
  for (T i = 1; i * i <= n; i++) {
    if (!(n % i)) {
      r.eb(i);
      if (i * i != n)
        r.eb(n / i);
    }
  }
  return r;
}

// --- functions which take more than 1 argument --- //
template <class S, class T> inline bool chmax(S &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class S, class T> inline bool chmin(S &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class S, class T> inline long long bpow(S m, T n) {
  ll r = 1;
  while (n > 0) {
    if (n & 1)
      r *= m;
    m *= m;
    n /= 2;
  }
  return r;
}
template <class S, class T>
inline common_type<S, T> nPr(const S &n, const T &k) {
  if (n < k || n < 0 || k < 0)
    return 0;
  T r = 1;
  brep(i, n - k + 1, n) r *= i;
  return r;
}
template <class S, class T> inline common_type<S, T> nCr(const S &n, T k) {
  if (n < k || n < 0 || k < 0)
    return 0;
  T r = 1;
  k = min(k, n - k);
  brep(i, n - k + 1, n) r *= i;
  return r / factorial(k);
}
template <class T> inline void prints(const T &v) { cout << v << '\\n'; }
template <class S, class... T> inline void prints(const S &v, const T &...w) {
  cout << v << ' ';
  prints(w...);
}

// --- functions which take vector/deque as argument --- //
template <class T> inline void printD(const vector<T> &v, string d) {
  rep(i, sz(v) - 1) cout << v[i] << d;
  cout << *v.rbegin() << '\\n';
}
template <class T> inline void printD(const vector<vector<T>> &v, string d) {
  for (const auto &x : v)
    printD(x, d);
}
template <class T> inline bool in(const T &k, const vector<T> &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const int &k, const vector<ll> &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const ll &k, const vector<int> &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const char &k, const string &v) {
  return find(all(v), k) != v.end();
}
inline bool in(const char *&k, const vector<string> &v) {
  return find(all(v), k) != v.end();
}
template <class T> inline double abs(const vector<T> &v) {
  return sqrt(reduce(all(v), 0.0, [](T s, T v) { return s += v * v; }));
}
template <class T> inline T min(const vector<T> &v) {
  return *min_element(all(v));
}
template <class T> inline T max(const vector<T> &v) {
  return *max_element(all(v));
}
template <class T> inline T sum(const vector<T> &v) {
  return reduce(all(v), (T)0);
}
template <class T> inline T gcd(const vector<T> &v) {
  T r = v[0];
  brep(i, 1, sz(v) - 1) r = gcd(r, v[i]);
  return r;
}
template <class T> inline T lcm(const vector<T> &v) {
  T r = v[0];
  brep(i, 1, sz(v) - 1) r = lcm(r, v[i]);
  return r;
}
template <class T> inline T vectorAdd(const T &u, const T &v) {
  T r(u.size());
  rep(i, u.size()) r[i] = u[i] + v[i];
  return r;
}
template <class T> inline T vectorSubtract(const T &u, const T &v) {
  T r(u.size());
  rep(i, u.size()) r[i] = u[i] - v[i];
  return r;
}
template <class T> inline T vectorMultiply(const T &u, const T &v) {
  T r(u.size());
  rep(i, u.size()) r[i] = u[i] * v[i];
  return r;
}
template <class T>
inline T dotProduct(const deque<bool> &u, const vector<T> &v) {
  T r = 0;
  rep(i, u.size()) if (u[i]) r += v[i];
  return r;
}
template <class S, class T>
inline common_type<S, T> dotProduct(const vector<S> &u, const vector<T> &v) {
  T r = 0;
  rep(i, u.size()) r += u[i] * v[i];
  return r;
}
template <class S, class T> inline void sortBySecond(vector<pair<S, T>> &v) {
  sort(all(v), [](auto L, auto R) { return L.second < R.second; });
}

// --- functions which take set/map as argument --- //
template <class T> inline T min(const set<T> &v) {
  return *min_element(all(v));
}
template <class T> inline T min(const uset<T> &v) {
  return *min_element(all(v));
}
template <class T> inline T max(const set<T> &v) {
  return *max_element(all(v));
}
template <class T> inline T max(const uset<T> &v) {
  return *max_element(all(v));
}
template <class T> inline T sum(const set<T> &v) {
  return reduce(all(v), (T)0);
}
template <class T> inline T sum(const uset<T> &v) {
  return reduce(all(v), (T)0);
}
template <class T> inline T gcd(const set<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : gcd(r, x);
  return r;
}
template <class T> inline T gcd(const uset<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : gcd(r, x);
  return r;
}
template <class T> inline T lcm(const set<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : lcm(r, x);
  return r;
}
template <class T> inline T lcm(const uset<T> &v) {
  T r = 0;
  for (const T &x : v)
    r = (r == 0) ? x : lcm(r, x);
  return r;
}
template <class T> inline bool in(const T &k, const set<T> &v) {
  return find(all(v), k) != v.end();
}
template <class T> inline bool in(const T &k, const uset<T> &v) {
  return find(all(v), k) != v.end();
}
template <class S, class T> inline pair<S, T> min(const map<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmin(r.se, p.se))
      r = p;
  return r;
}
template <class S, class T> inline pair<S, T> min(const umap<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmin(r.se, p.se))
      r = p;
  return r;
}
template <class S, class T> inline pair<S, T> max(const map<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmax(r.se, p.se))
      r = p;
  return r;
}
template <class S, class T> inline pair<S, T> max(const umap<S, T> &m) {
  pair<S, T> r = *m.begin();
  for (const auto &p : m)
    if (chmax(r.se, p.se))
      r = p;
  return r;
}

// --- functions for debugging --- //
template <class T> inline void observe(const char *n, T &&v) {
  cerr << n << ": " << v << '\\n';
}
template <class S, class... T>
inline void observe(const char *n, S &&v, T &&...w) {
  const char *c = strchr(n + 1, ',');
  cerr.write(n, c - n) << ": " << v << " |";
  observe(c + 1, w...);
}
template <class T> inline void dmp(const vector<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class T> inline void dmp(const deque<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class T> inline void dmp(const set<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class T> inline void dmp(const uset<T> &v) {
  cerr << "[ ";
  for (const T &x : v)
    cerr << x << ' ';
  cerr << "]\\n";
}
template <class P> inline void dmp(const P &p) {
  cerr << "{ " << p.first << ' ' << p.second << " } ";
}
template <class T> inline void dmp(const vector<vector<T>> &v) {
  for (const auto &x : v)
    dmp<T>(x);
}
template <class T> inline void dmp(const vector<deque<T>> &v) {
  for (const auto &x : v)
    dmp<T>(x);
}
template <class S, class T> inline void dmp(const map<S, T> &m) {
  cerr << "[ ";
  for (const auto &p : m)
    cerr << "{ " << p.first << ", " << p.second << " } ";
  cerr << "]\\n";
}
template <class S, class T> inline void dmp(const umap<S, T> &m) {
  cerr << "[ ";
  for (const auto &p : m)
    cerr << "{ " << p.first << ", " << p.second << " } ";
  cerr << "]\\n";
}
template <class S, class T> inline void dmp(const vector<pair<S, T>> &v) {
  cerr << "[ ";
  for (const auto &x : v)
    dmp<pair<S, T>>(x);
  cerr << " ]\\n";
}
#pragma endregion template

inline int isSquare(const int &n) {
  int ret = 0;
  while (1) {
    ret++;
    if (ret * ret == n)
      return ret;
    if (ret * ret > n)
      return -1;
  }
}

void solve(int N) {
  xrep(i, N) {
    int ret = 0;
    int Limit = sqrt(i);
    xrep(x, Limit) {
      xrep(y, Limit) {
        int ex = 4 * i - 3 * x * x - 3 * y * y - 2 * x * y;
        if (ex < 0)
          break;
        int k = isSquare(ex);
        if (k == -1)
          continue;
        int z = k - x - y;
        ret += ((z & 1) == 0 && z >= 2);
        // if ((z & 1) == 0 && z >= 2) {
        //   z >>= 1;
        //   obs(i,x,y,z);
        //   ret++;
        // }
      }
    }
  pr:
    printf("%d\\n", ret);
  }
}

int main() {
  int N;
  scanf("%d", &N);
  solve(N);
  return 0;
}