Go: package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func read() string {
	sc.Scan()
	return sc.Text()
}

func main() {
	sc.Split(bufio.ScanLines)
	area := 0
	for sc.Scan() {
		n, _ := strconv.Atoi(sc.Text())
		area = 0

		for i := 1; i < 600/n; i++ {
			area += n * (n * i) * (n * i)
		}

		fmt.Println(area)

	}
}

C++: #include <iostream>
using namespace std;

//0014
int main(){
	int d;
	const int n = 600;
	
	while(cin >> d){
		int sum=0;
		int x=0;
		for(int i=0; i<n/d; ++i){
			sum+=d*x*x;
			x+=d;
		}
		cout << sum << endl;
	}
	return 0;
}

C++: #include <iostream>
using namespace std;

int main() {
    long d;
    while(cin >> d) {
        long count;
        for(int i=0; i<600; i+=d) {
            count += d*i*i;
        }
        cout << count << endl;
    }
    return 0;
}

C++: #include <iostream>
using namespace std;

int main() {
  int d;
  while (cin >> d) {
    int sum = 0;
    for (int i = 0; i < 600 / d; i++) {
      int x = i * d;
      sum += x * x * d;
    }
    cout << sum << endl;
  }
}

C++: #include<iostream>
#include<cstdio>
using namespace std;

void solve(int delta_x){
	int number_of_rectangle, height_of_rectangle;
	int integer = 0;
	number_of_rectangle = 600 / delta_x;
	for(int i = 1;i < number_of_rectangle;i++){
		height_of_rectangle = (delta_x * i) * (delta_x * i);
		integer += height_of_rectangle * delta_x;
	}
	cout << integer << endl;
}

int main(){
	int number_of_rectangle, delta_x;
	while(cin >> delta_x){
		solve(delta_x);
	}
	return 0;
}

C++: //50
#include<iostream>

#define S(X) ((X)*(X))

using namespace std;

int main(){
  for(int d;cin>>d;){
    int ans=0;
    for(int i=0;i<600/d;i++){
      ans+=d*d*d*i*i;
    }
    cout<<ans<<endl;
  }
  return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<string>
using namespace std;
int main(){
  int d,a,sum;
  while(cin >> d &&d){
    a = 600 / d;
    sum = 0;
    for(int i=1;i<a;i++){
      sum += d*d*i*d*i;
    }
    cout << sum << endl;
  }
}

C++: #include<iostream>
int main(){
	while(1){
		int d,s=0;
		std::cin>>d;
		if(std::cin.eof())break;
		for(int i=0;i<600;i+=d)s+=i*i*d;
		std::cout<<s<<std::endl;
	}
	return 0;
}

C++: #include <cassert>
#include <iostream>

int f(int x)
{
    return x * x;
}
int main()
{
    while(true){
        int d;
        std::cin >> d;
        if(std::cin.eof()) break;
        
        int s = 0;
        for(int x = d; x < 600; x += d){
            s += d * f(x);
        }
        std::cout << s << std::endl;;
    }
    return 0;
}

C++: #include <iostream>

using namespace std;


unsigned long long  f(unsigned long long x)
{
    return x*x;
}

int main()
{
    int d;
    while(cin >> d) {
        unsigned long long s;
        for(int i = d; i <= 600 - d; i += d) s += d * f(i);
        cout << s << endl;
    }
    return 0;
}

C++: #include<iostream>
using namespace std;

int main() {
	long int powedx, sum, d;
	while (cin >> d) {
		sum = 0;
		for (int i = d; i <= (600 - d); i += d) {
			powedx = i * i;
			sum += (powedx * d);
		}
		cout << sum << endl;
	}
	return 0;
}

C++: #include <cstdio>
using namespace std;

int main() {
  int d, s;
  while (~scanf("%d", &d)) {
    s = 0;
    for (int i = d; i < 600; i += d) {
      s += i * i * d;
    }
    printf("%d\n", s);
  }
}

C++: #include <iostream>

using namespace std;

int main()
{
    int d;
    int Answer = 0;

    while(cin >> d)
    {
        for(int i = d; i < 600; i+=d)
        {
            Answer = Answer + i*i*d;
        }

        cout << Answer;
    }

}

C++: #include<algorithm>
#include<cassert>
#include<climits>
#include<cmath>
#include<cstring>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>

using namespace std;

using lint = long long;
using P = pair<int, int>;
using LLP = pair<long long, long long>;

#define REP(i, x, n) for(int i = (x), i##_len = int(n) ; i < i##_len ; ++i)
#define rep(i, n) for(int i = 0, i##_len = int(n) ; i < i##_len ; ++i)
#define reps(i, n) for(int i = 1, i##_len = int(n) ; i <= i##_len ; ++i)
#define rrep(i, n) for(int i = int(n) - 1 ; i >= 0 ; --i)
#define rreps(i, n) for(int i = int(n) ; i > 0 ; --i)
#define SORT(x) sort((x).begin(), (x).end())
#define SORT_INV(x) sort((x).rbegin(), (x).rend())
#define TWINS(x) cout << ((x) ? "Yay!" : ":(") << endl

constexpr int IINF = (1 << 30) - 1;
constexpr long long LLINF = 1LL << 61;
constexpr double EPS = 1e-8;

const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, 1, 0, -1};
const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};

template<typename T>
bool chmax(T &a, T b){
    if(a < b){
        a = b;
        return true;
    }
    return false;
}

template<typename T>
bool chmin(T &a, T b){
    if(b < a){
        a = b;
        return true;
    }
    return false;
}

int f(int x){
    return x * x;
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);

    int d;
    while(cin >> d){
        int ans = 0;
        for(int i = 0 ; i < 600 ; i += d){
            ans += d * f(i);
        }
        cout << ans << endl;
    }

    return 0;
}

C++: #include<iostream>
#include<cstdio>
using namespace std;

int f(int x)
{
  return x * x;
}

int main(void)
{
  int a=0, i, d;

  scanf("%d", &d);

  for(i=1; i < 600/d; i++)
  {
    a = d * f(d*i) + a;
  }

  printf("%d", a);

  return 0;
}

C++: #include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit(b) (1ll << (b))

using namespace std;

using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;

inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T power(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }

void solve() {
  int n;
  while (cin >> n) {
    int ans = 0;
    for (int i = 0; i < 600; i += n) {
      ans += i * i * n;
    }
    cout << ans << '\n';
  }
}