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

#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;

using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define int ll

const double PI = acos(-1.0);
const int MOD = (int)pow(10, 9) + 7;

#define YES(n) std::cout << ((n) ? "YES" : "NO") << endl;
#define Yes(n) std::cout << ((n) ? "Yes" : "No") << endl;
#define all(v) v.begin(), v.end()
#define Ini(a)                                                                 \\
  ll a;                                                                        \\
  cin >> a;
#define Inui(a)                                                                \\
  ull a;                                                                       \\
  cin >> a;
#define Ind(a)                                                                 \\
  double a;                                                                    \\
  cin >> a;
#define Ins(a)                                                                 \\
  string a;                                                                    \\
  cin >> a;
#define Inc(a)                                                                 \\
  char a;                                                                      \\
  cin >> a;
#define Inv(a, type, n)                                                        \\
  vector<type> a;                                                              \\
  a.reserve(n);                                                                \\
  for (ll i = 0; i < n; ++i) {                                                 \\
    type tmp;                                                                  \\
    cin >> tmp;                                                                \\
    a.emplace_back(tmp);                                                       \\
  }
#define Out(Bool, T, F) std::cout << ((Bool) ? T : F) << endl;
#define Sort(v) sort(all(v));
#define Rsort(v, type) sort(all(v), greater<type>());
#define Rsort_s(v) sort(v.rbegin(), v.rend());

ll modinv(ll a, ll m) {
  ll b = m, u = 1, v = 0;
  while (b) {
    ll t = a / b;
    a -= t * b;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  u %= m;
  if (u < 0)
    u += m;
  return u;
}

inline void finish() {
  std::cout << -1 << endl;
  exit(0);
}

template <typename T> inline void debug(vector<T> &v) {
  if (v.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  std::cout << "[";
  for (size_t i = 0; i < v.size() - 1; ++i) {
    std::cout << v[i] << ", ";
  }
  std::cout << v[v.size() - 1] << "]" << endl;
}

template <typename T, typename U> inline void debug(map<T, U> &m) {
  if (m.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  for (pair<T, U> p : m) {
    std::cout << "[" << p.first << ", " << p.second << "], ";
  }
  std::cout << endl;
}
template <typename T, typename U> inline void debug(vector<pair<T, U>> &ps) {
  if (ps.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  for (pair<T, U> p : ps) {
    std::cout << "[" << p.first << ", " << p.second << "], ";
  }
  std::cout << endl;
}
template <typename T> inline void debug(multiset<T> &m) {
  if (m.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  std::cout << "[";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    std::cout << *itr << ", ";
  }
  std::cout << "]" << endl;
}

class Pos {
public:
  double x, y;
  Pos(double x, double y) {
    this->x = x;
    this->y = y;
  }
  Pos() {
    x = 0.0;
    y = 0.0;
  }

  bool operator==(Pos &pos2) {
    if (this->x == pos2.x && this->y == pos2.y) {
      return true;
    }
    return false;
  }
  bool operator!=(Pos &pos2) { return !(*this == pos2); }
};

class BitFlag {
private:
  ull m_bitFlag;
  int m_size;
  ull m_upper;
  vector<ull> m_exponentiation;

public:
  BitFlag(ull n) {
    if (n > 64) {
      throw string(("ビットフラグは64bitまでしか対応してない 指定された数=" +
                    to_string(n))
                       .c_str());
    }
    m_bitFlag = 0;
    m_size = n;
    m_upper = (int)pow(2, n) - 1;

    m_exponentiation.resize(n);
    for (ull i = 0; i < n; ++i) {
      m_exponentiation[i] = (ll)pow(2, i);
    }
  }

  void Set(ull n) {
    if (n > m_upper) {
      throw string(
          (to_string(n) + "は" + to_string(m_size) + "bitでは表現できない")
              .c_str());
    }
    m_bitFlag = n;
  }

  void Set(string &s) {
    if (s.size() > (size_t)m_size) {
      throw string(
          ("\\"" + s + "\\"が" + to_string(m_size) + "bitよりも長いので無理")
              .c_str());
    }
    int i = s.size() - 1;
    m_bitFlag = 0;
    for (const char c : s) {
      if (c != '0') {
        m_bitFlag += m_exponentiation[i];
      }
      i--;
    }
  }

  ll size() { return m_size; }

  bool operator[](int i) {
    if (i >= m_size) {
      throw string(("指定した値が領域を超えている index=" + to_string(i) +
                    " size=" + to_string(m_size))
                       .c_str());
    }
    return (m_bitFlag & m_exponentiation[i]) == 0 ? false : true;
  }

  BitFlag &operator++() {
    m_bitFlag++;
    if (m_bitFlag > m_upper) {
      m_bitFlag = 0;
    }
    return *this;
  }

  BitFlag operator++(signed) {
    BitFlag b = *this;
    m_bitFlag++;
    if (m_bitFlag > m_upper) {
      m_bitFlag = 0;
    }
    return b;
  }

  BitFlag &operator+=(const int n) {
    this->m_bitFlag += n;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag &operator-=(const int n) {
    this->m_bitFlag -= n;
    return *this;
  }
  BitFlag &operator+=(const BitFlag &b) {
    this->m_bitFlag += b.m_bitFlag;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag &operator-=(const BitFlag &b) {
    this->m_bitFlag -= b.m_bitFlag;
    return *this;
  }

  BitFlag operator+(int n) {
    m_bitFlag += n;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag operator-(int n) {
    m_bitFlag -= n;
    return *this;
  }
  BitFlag operator+(BitFlag &b) {
    this->m_bitFlag += b.m_bitFlag;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag operator-(BitFlag &b) {
    this->m_bitFlag -= b.m_bitFlag;
    return *this;
  }

  bool operator==(BitFlag &comp) {
    return comp.m_bitFlag == this->m_bitFlag ? true : false;
  }
  bool operator!=(BitFlag &comp) { return !(*this == comp); }

  friend ostream &operator<<(ostream &o, const BitFlag &b);
};

ostream &operator<<(ostream &o, const BitFlag &b) {
  for (ll i = 0; i < b.m_size; ++i) {
    std::cout << ((b.m_bitFlag & b.m_exponentiation[i]) == 0 ? false : true);
  }
  return o;
}

class Mod {
public:
  static inline ll Add(ll a, ll b) { return (a + b) % MOD; }

  static inline ll Sub(ll a, ll b) {
    ll ans = (a - b) % MOD;
    return (ans < 0) ? (ans + MOD) : ans;
  }

  static inline ll Mul(ll a, ll b) { return (a * b) % MOD; }

  static inline ll Div(ll a, ll b) { return (a % MOD) * modinv(b, MOD) % MOD; }
};

inline double distance(Pos p1, Pos p2) {
  return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

inline ull Kaijo(int n) {
  ull ans = 1;
  for (int i = 2; i <= n; ++i) {
    ans *= i;
  }
  return ans;
}

template <typename T> inline int GetKeta(T num) {
  return to_string(num).length();
}

void Main();
inline void DebugMain() {
  while (true) {
    Main();
    std::cout << endl;
  }
}

signed main() {
  bool debug = false;
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  std::cout << fixed << setprecision(15);

  if (debug) {
    std::cout << "\\x1b[41m"
              << "Debug Mode このまま提出すると死" << endl;
  }
  try {
    (debug) ? DebugMain() : Main();
  } catch (exception &e) {
    std::cout << e.what() << endl;
  } catch (string &s) {
    std::cout << s << endl;
  }

  return 0;
}

template <typename T> inline bool isExistArray(vector<T> &v, T &str) {
  if (v.size() == 0) {
    return false;
  }
  for (string &s : v) {
    if (s == str) {
      return true;
    }
  }
  return false;
}

inline int ctoi(char c) { return (int)c - 48; }

template <typename T> inline int Find(vector<T> &v, T n) {
  for (size_t i = 0; i < v.size(); ++i) {
    if (v[i] == n) {
      return i;
    }
  }
  return -1;
}

inline bool isSameArray(vector<int> &v1, vector<int> &v2) {
  for (size_t i = 0; i < v1.size(); ++i) {
    if (v1[i] != v2[i]) {
      return false;
    }
  }
  return true;
}

inline bool isSeisu(double n) {

  if (std::floor(n) == n) {
    return true;
  }
  return false;
}

int gcd(int a, int b) {
  if (a % b == 0) {
    return (b);
  } else {
    return (gcd(b, a % b));
  }
}

int lcm(int a, int b) { return a * b / gcd(a, b); }

inline ll Kiriage(ll a, ll b) { return (a + (b - 1)) / b; }

template <class T> inline void container_sort(std::vector<T> &v) {
  std::sort(all(v));
}
template <class T> inline void container_sort(std::list<T> &v) { v.sort(); }

template <class T> inline void Unique(T &v) {

  container_sort(v);
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

inline vector<bool> GetPrimeTable(int n) {
  vector<bool> primeTable(n + 1, true);
  int sqr = (int)sqrt(n);
  primeTable[0] = false; // 0は素数じゃない
  primeTable[1] = false; // 1は素数じゃない
  for (int i = 2; i <= sqr; ++i) {
    if (primeTable[i]) {
      for (size_t j = i + i; j < primeTable.size(); j += i) {
        primeTable[j] = false;
      }
    }
  }
  return primeTable;
}

inline vector<ll> GetPrimeNumbers(int n) {
  vector<bool> primeTable = GetPrimeTable(n);
  vector<ll> result;
  if (n < 2) {
    result;
  }
  result.reserve(n / 2);
  for (size_t i = 0; i < primeTable.size(); ++i) {
    if (primeTable[i]) {
      result.push_back(i);
    }
  }
  result.shrink_to_fit();
  return result;
}

inline map<ll, ll> PrimeFact(ull n) {
  ull num = 2;
  map<ll, ll> result;
  while (true) {
    if (n % num == 0) {
      if (result.count(num) == 0) {
        result.insert(pair<ll, ll>{num, 1});
      } else {
        result[num]++;
      }
      n /= num;
    } else {
      if (++num > sqrt(n)) {
        if (result.size() == 0 || n != 1) {
          result.insert(pair<ll, ll>{n, 1});
        }
        return result;
      }
    }
  }
}

void recursive_comb(int *indexes, int s, int rest,
                    std::function<void(int *)> f) {
  if (rest == 0) {
    f(indexes);
  } else {
    if (s < 0)
      return;
    recursive_comb(indexes, s - 1, rest, f);
    indexes[rest - 1] = s;
    recursive_comb(indexes, s - 1, rest - 1, f);
  }
}

template <typename T> inline vector<int> GetBorder(vector<T> &v) {
  T tmp = v[0];
  vector<int> border;
  size_t vSize = v.size();
  border.reserve(vSize / 3); // 雑に確保
  for (size_t i = 1; i < vSize; ++i) {
    if (v[i] != tmp) {
      border.push_back(i);
      tmp = v[i];
    }
  }
  return border;
}

template <typename T, typename U>
inline vector<int> GetBorder(vector<pair<T, U>> &ps) {
  T tmp = ps[0].first;
  vector<int> border;
  size_t psSize = ps.size();
  border.reserve(psSize / 3); // 雑に確保
  for (size_t i = 1; i < psSize; ++i) {
    if (ps[i].first != tmp) {
      border.push_back(i);
      tmp = ps[i].first;
    }
  }
  return border;
}

// foreach_comb(n, k, [](int*indexes){
// });
//  nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(int *)> f) {
  int *indexes = new int[k];
  recursive_comb(indexes, n - 1, k, f);
}

template <typename T> inline T MultisetPopBack(multiset<T> &m) {
  auto iter = m.end();
  iter--;
  T tmp = *iter;
  m.erase(m.find(*iter));
  return tmp;
}

template <typename T> inline T MultisetPopFront(multiset<T> &m) {
  auto iter = m.begin();
  T tmp = *iter;
  m.erase(m.find(*iter));

  return tmp;
}

inline void Main() {
  Ini(N);

  for (int i = 1; i <= N; ++i) {
    int count = 0;
    for (int x = 1; x <= 100; ++x) {
      int xx = x * x;
      for (int y = 1; y <= 100; ++y) {
        int yy = y * y;
        int xy = x * y;
        for (int z = 1; z <= 100; ++z) {
          int ans = xx + yy + z * z + xy + y * z + z * x;
          if (ans == i) {
            count++;
          }
          if (ans >= i) {
            break;
          }
        }
      }
    }
    cout << count << endl;
  }
}

Error: TLE

Fixed submission:

#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <chrono>
#include <complex>
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;

using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define int ll

const double PI = acos(-1.0);
const int MOD = (int)pow(10, 9) + 7;

#define YES(n) std::cout << ((n) ? "YES" : "NO") << endl;
#define Yes(n) std::cout << ((n) ? "Yes" : "No") << endl;
#define all(v) v.begin(), v.end()
#define Ini(a)                                                                 \\
  ll a;                                                                        \\
  cin >> a;
#define Inui(a)                                                                \\
  ull a;                                                                       \\
  cin >> a;
#define Ind(a)                                                                 \\
  double a;                                                                    \\
  cin >> a;
#define Ins(a)                                                                 \\
  string a;                                                                    \\
  cin >> a;
#define Inc(a)                                                                 \\
  char a;                                                                      \\
  cin >> a;
#define Inv(a, type, n)                                                        \\
  vector<type> a;                                                              \\
  a.reserve(n);                                                                \\
  for (ll i = 0; i < n; ++i) {                                                 \\
    type tmp;                                                                  \\
    cin >> tmp;                                                                \\
    a.emplace_back(tmp);                                                       \\
  }
#define Out(Bool, T, F) std::cout << ((Bool) ? T : F) << endl;
#define Sort(v) sort(all(v));
#define Rsort(v, type) sort(all(v), greater<type>());
#define Rsort_s(v) sort(v.rbegin(), v.rend());

ll modinv(ll a, ll m) {
  ll b = m, u = 1, v = 0;
  while (b) {
    ll t = a / b;
    a -= t * b;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  u %= m;
  if (u < 0)
    u += m;
  return u;
}

inline void finish() {
  std::cout << -1 << endl;
  exit(0);
}

template <typename T> inline void debug(vector<T> &v) {
  if (v.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  std::cout << "[";
  for (size_t i = 0; i < v.size() - 1; ++i) {
    std::cout << v[i] << ", ";
  }
  std::cout << v[v.size() - 1] << "]" << endl;
}

template <typename T, typename U> inline void debug(map<T, U> &m) {
  if (m.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  for (pair<T, U> p : m) {
    std::cout << "[" << p.first << ", " << p.second << "], ";
  }
  std::cout << endl;
}
template <typename T, typename U> inline void debug(vector<pair<T, U>> &ps) {
  if (ps.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  for (pair<T, U> p : ps) {
    std::cout << "[" << p.first << ", " << p.second << "], ";
  }
  std::cout << endl;
}
template <typename T> inline void debug(multiset<T> &m) {
  if (m.size() == 0) {
    std::cout << "[]" << endl;
    return;
  }
  std::cout << "[";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    std::cout << *itr << ", ";
  }
  std::cout << "]" << endl;
}

class Pos {
public:
  double x, y;
  Pos(double x, double y) {
    this->x = x;
    this->y = y;
  }
  Pos() {
    x = 0.0;
    y = 0.0;
  }

  bool operator==(Pos &pos2) {
    if (this->x == pos2.x && this->y == pos2.y) {
      return true;
    }
    return false;
  }
  bool operator!=(Pos &pos2) { return !(*this == pos2); }
};

class BitFlag {
private:
  ull m_bitFlag;
  int m_size;
  ull m_upper;
  vector<ull> m_exponentiation;

public:
  BitFlag(ull n) {
    if (n > 64) {
      throw string(("ビットフラグは64bitまでしか対応してない 指定された数=" +
                    to_string(n))
                       .c_str());
    }
    m_bitFlag = 0;
    m_size = n;
    m_upper = (int)pow(2, n) - 1;

    m_exponentiation.resize(n);
    for (ull i = 0; i < n; ++i) {
      m_exponentiation[i] = (ll)pow(2, i);
    }
  }

  void Set(ull n) {
    if (n > m_upper) {
      throw string(
          (to_string(n) + "は" + to_string(m_size) + "bitでは表現できない")
              .c_str());
    }
    m_bitFlag = n;
  }

  void Set(string &s) {
    if (s.size() > (size_t)m_size) {
      throw string(
          ("\\"" + s + "\\"が" + to_string(m_size) + "bitよりも長いので無理")
              .c_str());
    }
    int i = s.size() - 1;
    m_bitFlag = 0;
    for (const char c : s) {
      if (c != '0') {
        m_bitFlag += m_exponentiation[i];
      }
      i--;
    }
  }

  ll size() { return m_size; }

  bool operator[](int i) {
    if (i >= m_size) {
      throw string(("指定した値が領域を超えている index=" + to_string(i) +
                    " size=" + to_string(m_size))
                       .c_str());
    }
    return (m_bitFlag & m_exponentiation[i]) == 0 ? false : true;
  }

  BitFlag &operator++() {
    m_bitFlag++;
    if (m_bitFlag > m_upper) {
      m_bitFlag = 0;
    }
    return *this;
  }

  BitFlag operator++(signed) {
    BitFlag b = *this;
    m_bitFlag++;
    if (m_bitFlag > m_upper) {
      m_bitFlag = 0;
    }
    return b;
  }

  BitFlag &operator+=(const int n) {
    this->m_bitFlag += n;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag &operator-=(const int n) {
    this->m_bitFlag -= n;
    return *this;
  }
  BitFlag &operator+=(const BitFlag &b) {
    this->m_bitFlag += b.m_bitFlag;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag &operator-=(const BitFlag &b) {
    this->m_bitFlag -= b.m_bitFlag;
    return *this;
  }

  BitFlag operator+(int n) {
    m_bitFlag += n;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag operator-(int n) {
    m_bitFlag -= n;
    return *this;
  }
  BitFlag operator+(BitFlag &b) {
    this->m_bitFlag += b.m_bitFlag;
    this->m_bitFlag %= m_upper;
    return *this;
  }
  BitFlag operator-(BitFlag &b) {
    this->m_bitFlag -= b.m_bitFlag;
    return *this;
  }

  bool operator==(BitFlag &comp) {
    return comp.m_bitFlag == this->m_bitFlag ? true : false;
  }
  bool operator!=(BitFlag &comp) { return !(*this == comp); }

  friend ostream &operator<<(ostream &o, const BitFlag &b);
};

ostream &operator<<(ostream &o, const BitFlag &b) {
  for (ll i = 0; i < b.m_size; ++i) {
    std::cout << ((b.m_bitFlag & b.m_exponentiation[i]) == 0 ? false : true);
  }
  return o;
}

class Mod {
public:
  static inline ll Add(ll a, ll b) { return (a + b) % MOD; }

  static inline ll Sub(ll a, ll b) {
    ll ans = (a - b) % MOD;
    return (ans < 0) ? (ans + MOD) : ans;
  }

  static inline ll Mul(ll a, ll b) { return (a * b) % MOD; }

  static inline ll Div(ll a, ll b) { return (a % MOD) * modinv(b, MOD) % MOD; }
};

inline double distance(Pos p1, Pos p2) {
  return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

inline ull Kaijo(int n) {
  ull ans = 1;
  for (int i = 2; i <= n; ++i) {
    ans *= i;
  }
  return ans;
}

template <typename T> inline int GetKeta(T num) {
  return to_string(num).length();
}

void Main();
inline void DebugMain() {
  while (true) {
    Main();
    std::cout << endl;
  }
}

signed main() {
  bool debug = false;
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  std::cout << fixed << setprecision(15);

  if (debug) {
    std::cout << "\\x1b[41m"
              << "Debug Mode このまま提出すると死" << endl;
  }
  try {
    (debug) ? DebugMain() : Main();
  } catch (exception &e) {
    std::cout << e.what() << endl;
  } catch (string &s) {
    std::cout << s << endl;
  }

  return 0;
}

template <typename T> inline bool isExistArray(vector<T> &v, T &str) {
  if (v.size() == 0) {
    return false;
  }
  for (string &s : v) {
    if (s == str) {
      return true;
    }
  }
  return false;
}

inline int ctoi(char c) { return (int)c - 48; }

template <typename T> inline int Find(vector<T> &v, T n) {
  for (size_t i = 0; i < v.size(); ++i) {
    if (v[i] == n) {
      return i;
    }
  }
  return -1;
}

inline bool isSameArray(vector<int> &v1, vector<int> &v2) {
  for (size_t i = 0; i < v1.size(); ++i) {
    if (v1[i] != v2[i]) {
      return false;
    }
  }
  return true;
}

inline bool isSeisu(double n) {

  if (std::floor(n) == n) {
    return true;
  }
  return false;
}

int gcd(int a, int b) {
  if (a % b == 0) {
    return (b);
  } else {
    return (gcd(b, a % b));
  }
}

int lcm(int a, int b) { return a * b / gcd(a, b); }

inline ll Kiriage(ll a, ll b) { return (a + (b - 1)) / b; }

template <class T> inline void container_sort(std::vector<T> &v) {
  std::sort(all(v));
}
template <class T> inline void container_sort(std::list<T> &v) { v.sort(); }

template <class T> inline void Unique(T &v) {

  container_sort(v);
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

inline vector<bool> GetPrimeTable(int n) {
  vector<bool> primeTable(n + 1, true);
  int sqr = (int)sqrt(n);
  primeTable[0] = false; // 0は素数じゃない
  primeTable[1] = false; // 1は素数じゃない
  for (int i = 2; i <= sqr; ++i) {
    if (primeTable[i]) {
      for (size_t j = i + i; j < primeTable.size(); j += i) {
        primeTable[j] = false;
      }
    }
  }
  return primeTable;
}

inline vector<ll> GetPrimeNumbers(int n) {
  vector<bool> primeTable = GetPrimeTable(n);
  vector<ll> result;
  if (n < 2) {
    result;
  }
  result.reserve(n / 2);
  for (size_t i = 0; i < primeTable.size(); ++i) {
    if (primeTable[i]) {
      result.push_back(i);
    }
  }
  result.shrink_to_fit();
  return result;
}

inline map<ll, ll> PrimeFact(ull n) {
  ull num = 2;
  map<ll, ll> result;
  while (true) {
    if (n % num == 0) {
      if (result.count(num) == 0) {
        result.insert(pair<ll, ll>{num, 1});
      } else {
        result[num]++;
      }
      n /= num;
    } else {
      if (++num > sqrt(n)) {
        if (result.size() == 0 || n != 1) {
          result.insert(pair<ll, ll>{n, 1});
        }
        return result;
      }
    }
  }
}

void recursive_comb(int *indexes, int s, int rest,
                    std::function<void(int *)> f) {
  if (rest == 0) {
    f(indexes);
  } else {
    if (s < 0)
      return;
    recursive_comb(indexes, s - 1, rest, f);
    indexes[rest - 1] = s;
    recursive_comb(indexes, s - 1, rest - 1, f);
  }
}

template <typename T> inline vector<int> GetBorder(vector<T> &v) {
  T tmp = v[0];
  vector<int> border;
  size_t vSize = v.size();
  border.reserve(vSize / 3); // 雑に確保
  for (size_t i = 1; i < vSize; ++i) {
    if (v[i] != tmp) {
      border.push_back(i);
      tmp = v[i];
    }
  }
  return border;
}

template <typename T, typename U>
inline vector<int> GetBorder(vector<pair<T, U>> &ps) {
  T tmp = ps[0].first;
  vector<int> border;
  size_t psSize = ps.size();
  border.reserve(psSize / 3); // 雑に確保
  for (size_t i = 1; i < psSize; ++i) {
    if (ps[i].first != tmp) {
      border.push_back(i);
      tmp = ps[i].first;
    }
  }
  return border;
}

// foreach_comb(n, k, [](int*indexes){
// });
//  nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(int *)> f) {
  int *indexes = new int[k];
  recursive_comb(indexes, n - 1, k, f);
}

template <typename T> inline T MultisetPopBack(multiset<T> &m) {
  auto iter = m.end();
  iter--;
  T tmp = *iter;
  m.erase(m.find(*iter));
  return tmp;
}

template <typename T> inline T MultisetPopFront(multiset<T> &m) {
  auto iter = m.begin();
  T tmp = *iter;
  m.erase(m.find(*iter));

  return tmp;
}

inline void Main() {
  Ini(N);

  for (int i = 1; i <= N; ++i) {
    int count = 0;
    for (int x = 1; x <= 100; ++x) {
      int xx = x * x;
      for (int y = 1; y <= 100; ++y) {
        int yy = y * y;
        int xy = x * y;
        for (int z = 1; z <= 100; ++z) {
          if (xx + yy + z * z + xy + y * z + z * x == i) {
            count++;
          }
        }
      }
    }
    cout << count << endl;
  }
}