Go: package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	for sc.Scan() {
		d, _ := strconv.Atoi(sc.Text())
		var area int
		for i := 1; i*d < 600; i++ {
			area += d * (d * i) * (d * i)
		}
		fmt.Println(area)
	}
}

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

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

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

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

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

  return 0;
}

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

C++: #include <stdio.h>

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

int main() {
	int d;
	int ans;
	int i;

	while(scanf("%d", &d) != EOF) {
		ans = 0;

		for(i = 0; i < 600 / d; i++)
			ans += d * func(i * d);

		printf("%d\n", ans);
	}

	return 0;
}

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

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

C++: #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>
#include<bitset>
#include<limits.h>
#include<cassert>
#include<iterator>
#include<complex>
#include<stack>
#include<sstream>
#include<iterator>
using namespace std;
typedef  long long int lint;
typedef pair<int, int> IP;
typedef pair<lint, lint> LLP;
typedef pair<char, char>CP;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define sort(v) sort((v).begin(), (v).end())
#define reverse(v) reverse((v).begin(), (v).end())
#define upper(v,hoge) upper_bound(v.begin(),v.end(),hoge)
#define lower(v,hoge) lower_bound(v.begin(),v.end(),hoge)
#define llower(v,hoge) *lower_bound(v.begin(), v.end(), hoge)
#define lupper(v,hoge) *upper_bound(v.begin(), v.end(), hoge)

int main() {
	int D;
	while (cin >> D) {
		int ans = 0;
		int now = 0;
		while (1) {
			now += D;
			if (now == 600) {
				cout << ans << endl;
				break;
			}
			else {
				ans += D * now * now;
			}
		}
	}
}

C++: #include <stdio.h>

int main(void)
{
	int d;
	int n, i;
	int ans;
	
	n = 600;
	while (scanf("%d", &d) != EOF){
		ans = 0;
		
		for (i = 0; i < n; i += d){
			ans += (d * i * i);
		}
		
		printf("%d\n", ans);
	}
	
	return (0);
}

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

int main()
{
	int d, width;
	int s = 0;
	
	
	while(cin >> d){

		width = d;

		while(d<600){
			s += width * (d*d);

			d += width;
		}
		
		cout << s << endl;
		s = 0;
	}
	return 0;
}

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;
}