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;

int main(void) {
    int d, s;
    while (1) {
        cin >> d;
        if (cin.eof()) break;
        s = 0;
        for (int x = d; x < 600; x += d) s += d * x * x;
        cout << s << endl;
    }
    return 0;
}

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

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

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

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int d;
    while(cin>>d){
        int s=0;
        for(int i=0; i<600; i+=d) s+=i*i*d;
        cout<<s<<'\n';
    }
    return 0;
}

C++: 
#define _USE_MATH_DEFINES
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <memory>
#include <string>

#include <algorithm>
#include <complex>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>

using namespace std;

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#define __typeof__ decltype
#endif

#define ITER(c)         __typeof__((c).begin())
#define FOREACH(it, c)  for (ITER(c) it=(c).begin(); it != (c).end(); ++it)
#define RITER(c)        __typeof__((c).rbegin())
#define RFOREACH(it, c) for (RITER(c) it=(c).rbegin(); it != (c).rend(); ++it)
#define REP(i, n)       REPEAT(i, 0, n)
#define REPEAT(i, k, n) for (int i = (k); i < (n); ++i)
#define REVREP(i, n)    for (int i = ((n)-1); i >= 0; --i)
#define ESIZEOF(A)      (sizeof(A)/sizeof((A)[0]))
#define MIN(p1,p2)      (((p1)<(p2))?(p1):(p2))
#define MAX(p1,p2)      (((p1)>(p2))?(p1):(p2))
#define CIN_NO_SYNC     do { cin.tie(0); ios_base::sync_with_stdio(false); } while(0)

int main(void){
    CIN_NO_SYNC;
    int d;

    while(cin >> d){
        if(d < 1) break;
        int t = 0;
        for(int i = d; i < 600; i += d){
            t += i*i*d;
        }
        cout << t << endl;
    }
    return 0;
}

C++: #include <stdio.h>>
int f(int d) {
　　return (d*d);
}

int main(void){
    int d;
    while(scanf("%d", &d) != EOF) {
       printf("%d\n",f(d));
    }
    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

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

C++: #include <cstdio>
#include <bitset>
#include <cmath>
#include <complex>
#include <vector>
#include <algorithm>
#include <stack>

#define EPS 1e-6

using namespace std;
typedef complex<double> coor;

double cross(coor a, coor b)
{
  return a.real() * b.imag() - a.imag() * b.real();
}

double dot(coor a, coor b)
{
  return a.real() * b.real() + a.imag() * b.imag();
}

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

C++: #include <bits/stdc++.h>
using namespace std;

#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define OP(m) cout << m << endl;
typedef long long ll;
typedef unsigned long long ull;

int main()
{
    int d;
    while (cin >> d)
    {
        int area = 0;
        for (int i = d; i <= 600 - d; i += d)
        {
            area += d * pow(i, 2);
        }
        OP(area)
    }

    return 0;
}

C++: #include <iostream>
using namespace std;
int main(void){
    // Here your code !
    int d;
    int s;
    
    while(cin>>d){
        s=0;
        for(int i=1;i<=(600/d)-1;i++){
            s=s+d*(d*i)*(d*i);
        }
            cout<<s<<endl;
    }

}

C++: #include<iostream>
int main(){int d,i,a;while(std::cin>>d){for(i=1,a=0;i*d<600;i++)a+=i*i*d*d*d;std::cout<<a<<"\n";}}

C++: #include <iostream>

int main(void) {
    u_int d;
    auto f_x = [](const int x){ return x*x; };

    while (std::cin >> d) {
        u_int sum = 0;
        for (u_int i = 0; i + d <= 600; i += d) {
            sum += f_x(i) * d;
        }
        std::cout << sum << std::endl;
    }

    return 0;
}

C++: #include<iostream>
using namespace std;
int main() {
  int d;
  while(cin>>d) {
    int area=0;
    for(int i=d;i<=600-d;i+=d) {
      area+=i*i*d;
    }
    cout<<area<<endl;
  }
  return 0;
}

C++: //#define _GRIBCXX_DEBUG
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;


// ?????¬???????????¬??????
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion

// ???
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion

// Effective std
#pragma region ESTD
template<typename C, typename T>
constexpr int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F>
constexpr int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T>
void erase(C& c, T t) { remove(ALL(c), t), c.end(); }
template<typename C>
void remove(vector<C>& c, unsigned int index) { c.erase(c.begin()+index); }
template<typename C, typename T, typename U>
constexpr void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U>
constexpr void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C>
constexpr void reverse(C& c) { reverse(ALL(c)); }
template<typename C>
constexpr void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred>
constexpr void sort(C& c, Pred p) { sort(ALL(c), p); }
#pragma endregion

// ?????°
#pragma region CONST_VAL
#define PI (2*acos(0.0))
#define EPS (1e-9)
#define MOD (int)(1e9+7)
#pragma endregion


int main()
{
    int d;
    while(cin>>d) {
        int n=0, s=0;
        while(n<600) {
            s+=n*n*d;
            n+=d;
        }
        P(s);
    }
    return 0;
}