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++: // This is free and unencumbered software released into the public domain.

// Anyone is free to copy, modify, publish, use, compile, sell, or
// distribute this software, either in source code form or as a compiled
// binary, for any purpose, commercial or non-commercial, and by any
// means.

// In jurisdictions that recognize copyright laws, the author or authors
// of this software dedicate any and all copyright interest in the
// software to the public domain. We make this dedication for the benefit
// of the public at large and to the detriment of our heirs and
// successors. We intend this dedication to be an overt act of
// relinquishment in perpetuity of all present and future rights to this
// software under copyright law.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

// For more information, please refer to <http://unlicense.org>

/****************/
/* template.hpp */
/****************/

#include <algorithm>
#include <cassert>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <numeric>

using std::abs;
using std::cerr;
using std::cout;
using std::endl;
using std::max;
using std::min;
using std::numeric_limits;
using std::swap;

struct BoolName : std::numpunct<char> {
  std::string t, f;
  BoolName (std::string t, std::string f) : t(t), f(f) {}
  std::string do_truename() const {return t;}
  std::string do_falsename() const {return f;}
};

void set_bool_name(std::string t, std::string f) {
  cout.imbue(std::locale(cout.getloc(), new BoolName(t, f)));
}

struct Initializer {
  Initializer() {
    cout << std::fixed << std::setprecision(15) << std::boolalpha;
    set_bool_name("Yes", "No");
  }
} initializer;

struct Input {
  bool eof;

  Input() : eof(false) {}

  operator char() {
    char v;
    this->eof = (std::scanf("%c", &v) != 1);
    return v;
  }

  operator int() {
    int v;
    this->eof = (std::scanf("%d", &v) != 1);
    return v;
  }

  operator long() {
    long v;
    this->eof = (std::scanf("%ld", &v) != 1);
    return v;
  }

  operator long long() {
    long long v;
    this->eof = (std::scanf("%lld", &v) != 1);
    return v;
  }

  operator double() {
    double v;
    this->eof = (std::scanf("%lf", &v) != 1);
    return v;
  }

  operator long double() {
    long double v;
    this->eof = (std::scanf("%Lf", &v) != 1);
    return v;
  }

  void ignore() const {
    getchar();
  }
} in;

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

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

template<typename T, typename S> std::function<S(T)> cast() {
  return [](const T& t) { return static_cast<S>(t); };
}

/************/
/* main.cpp */
/************/

int main() {
  for (int d; d = in, !in.eof;) {
    int area = 0;
    for (int i = 0; i < 600; i += d) {
      area += i * i * d;
    }
    cout << area << endl;
  }
}

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

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

C++: #include<stdio.h>
main(){
  int i,d,s;
  while(scanf("%d",&d)!=EOF){
    s=0;
    for(i=0;i<600/d;i++){
      s+=(d*((d*i)*(d*i)));
    }
    printf("%d\n",s);
  }
  return 0;
}

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

using namespace std;

long long solve(int a, int b){

    long long ret = 1;
    while(b--) ret *= a;
    return ret;

}

int main(){

    int d;
    long long ans = 0;

    cin >> d;

    for(int i = 1; i < 600 / d; ++i){
        ans += solve(d * i, 2) * d;
    }

    cout << ans << endl;

}

C++: #include<iostream>
using namespace std;
int n;
int a[1000000];
int sum[1000000];
int main(int argc, char const *argv[])
{

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

C++: #include <iostream>

int main(void) {
    u_int d;
    auto f_x = [](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>
#include<cmath>
using namespace std;

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

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

int main() {
	int n;
	int h;
	long s=0;
	while(cin>>n){
		for(h=n;h<600;h+=n){
			s+=h*h*n;
		}
		cout<<s<<endl;
		s=0;
	}
	// your code goes here
	return 0;
}

C++: #include<stdio.h>
#include<math.h>
int f(int);

int main(void){
    int a=0, b=600, x,d;
    int n,i;
    int s,sum;
    scanf("%d　%d", &d,&d);
    n=(b-a)/d;
    
    sum=0.0;
    x=a;
    for(i=1; i<=n; i++){
        s=d*f(x);
        x+=d;
        sum+=s;
    }
    printf("%d\n", sum);
}
int f(int x){
    return x*x;
}

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

int main()
{
	std::uint32_t d;
	while (std::cin >> d) {
		std::uint32_t total = 0;
		for (std::uint32_t i = 0; i < (600 - d) / d; ++i) {
			total += i * i;
		}
		std::cout << d * d * d * total + (600 - d) * (600 - d) * d << std::endl;
	}
	return 0;
}

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

int main(){
	int n,x,i,a;
	while(cin >> n){
		a = 0;
		x = 600 / n;
		for(i = 1;i < x;++i){
			a += n * (n * i * n * i);
		}
		cout << a << endl;
	}
	return 0;
}

C++: #include <vector>
#include <iostream>
#include <valarray>
#include <string>
#include <algorithm>
#include <set>
#include <cstdio>
typedef unsigned long long ull;
typedef long long ll;
#define fst first
#define snd second
#define rep(i,n) for(ull i = 0;i<(n);i++)
#define rep1(i,n) for(ull i = 1;i<=(n);i++)
#define revrep(i,n) for(ull i = (n-1);i>=0;i--)
#define all(n) (n).begin(),(n).end()
#define show(x) cout << "debug " << #x << ":" << x << endl;
#define showvec(x) cout << endl << "debug " << #x << ";" << endl; \
    for(ull __i = 0;__i < x.size();__i++){ \
        for(ull __j = 0;__j<x[0].size();__j++){ \
            cout << x[__i][__j] << " "; \
        } \
        cout << endl; \
    } \
    cout << endl;
using namespace std;

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

int main(){
	int d;
	while(~scanf("%d\n",&d)){
		ll sum = 0;
		for(int x = d;x <= 600 - d; x += d){
			sum += d * f(x);
		}
		cout << sum << endl;
	}
}

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

int main() {
	int d,a;
	a = 0;
	while(cin >> d){
		for(int i = 0;i!=600;i+=d){
			a += i*i*d;

		}
		cout << a << endl;
		a = 0;
	}

	


	return 0;
}

C++: #include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <string>
using namespace std;

#define rep(i,n) for(int i=0;i<int(n);++i)

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