Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func nextString() string {
	scanner.Scan()
	return scanner.Text()
}

func nextInt() int {
	n, err := strconv.Atoi(nextString())
	if err != nil {
		fmt.Printf("strconv.Atoi failed: %v\n", err)
	}
	return n
}

func nextFloat64() (float64, error) {
	return strconv.ParseFloat(nextString(), 64)
}

func main() {
	scanner.Split(bufio.ScanWords)

	for {
		var s int
		var w, h float64
		_, err := fmt.Scanf("%d,%f,%f", &s, &w, &h)

		if err != nil {
			break
		}

		if w/(h*h) >= 25 {
			fmt.Println(s)
		}
	}
}

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

using namespace std;

//typedef
//------------------------------------------
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vbb;
typedef pair<int, int> pii;
typedef long long ll;
typedef unsigned long long ull;

//container util
//------------------------------------------
#define all(a)  (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define iter(i,c) for(auto i=(c).begin(); i!=(c).end(); ++i)

//repetition
//------------------------------------------
#define loop(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n)  loop(i,0,n)

//constant
//--------------------------------------------
const double eps = 1e-10;
const double pi  = acos(-1.0);
const double inf = (int)1e8;

// output vector
// ------------------------------------------
namespace std {
    template<typename T> ostream & operator<<(ostream& os, vector<T> const& v){
        for(auto it=v.begin(); it!=v.end(); ++it){
            os << *it << (it+1==v.end() ? "" : ",");
        }
        return os;
    }
}

//clear memory
#define clr(a) memset((a), 0 ,sizeof(a))

int gcd(int a, int b){
   int tmp;
   while(a%b!=0){
      tmp=a%b;
      a=b;
      b=tmp;
   }
}
 
int lcm(int a,int b){
   return a*b/gcd(a,b);
}
 
bool prime_number(int n){
   if(n==0||n==1) return false;
   vb a(n+1);
   fill(all(a),true);
   loop(i,2,n/2+1){
      if(!a[i]) continue;
      for(int j=2;i*j<=n;j++){
         a[i*j]=false;
      }
   }
   return a[n];
}

int main(){
   double a[3];
   char s;
   
   while(cin >> a[0]){
      rep(i,2) cin>>s>>a[i+1];
      if(a[1]/pow(a[2],2)>25) cout << a[0] << endl;
   }
}

C++: main(id){double w,h,bmi;for(;~scanf("%d,%lf,%lf",&id,&w,&h);)w/h/h>=25&&printf("%d\n",id);exit(0);}

C++: #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif

using namespace std;


int main ()
{
	double a , b , c ;
	char x;
	while( cin >> a >> x >> b >> x >> c )
	{
		if( b*1. / c / c >= 25 )cout << a << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>

using namespace std;

vector<string> split(string s, char delim = ',');
void dataInput(vector<vector<string> > &data);
double calcBMI(double w, double h);
void showFat(vector<vector<string> > data);

int main() {
  vector<vector<string> > data;

  dataInput(data);

  return 0;
}

vector<string> split(string s, char delim) {
	size_t pos = 0;
	vector<string> ret;
	while ((pos = s.find(delim)) != string::npos) {
		ret.push_back(s.substr(0, pos));
		s.erase(0, pos + 1);
	};
	ret.push_back(s);
	return ret;
}

void dataInput(vector<vector<string> > &data) {
  int i = 0;
  string temp;
  while(!cin.eof()) {
    cin >> temp;
    data[i].push_back(split(temp));

    i++;
  }

}

double calcBMI(double w, double h) {
  double BMI = 0.0;

  BMI = w / (h * h);

  return BMI
}

void showFat(vector<vector<string> > data) {
  int cnt = 0;
  double w = 0.0;
  double h = 0.0;

  while(cnt < data.size()) {
    w = stod(data[cnt][1]);
    h = stod(data[cnt][2]);
    if(25.0 <= calcBMI(w,h) {
      cout << data[cnt][0] << "\n";
    }
  }
}

C++: #include <cstdio>
#include <iostream>
#include <vector>

using namespace std;

int main() {
	vector<int> ans;
	int a;
	double b,c;
	while(scanf("%d,%f,%f",&a,&b,&c) != EOF){
		if((c/(b*b)) >= 25) ans.push_back(a);
	}
	for(int i=0; i<ans.size(); i++){
		cout<<ans[i]<<endl;
	}
	return 0;
}

C++: #include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;

typedef long long ll;
typedef vector<int> vint;
typedef vector<long long> vll;
typedef pair<int,int> pint;
typedef pair<long long, long long> pll;

#define MP make_pair
#define PB push_back
#define ALL(s) (s).begin(),(s).end()
#define EACH(i, s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T1, class T2> ostream& operator << (ostream &s, pair<T1,T2> P) 
{ return s << '<' << P.first << ", " << P.second << '>'; }
template<class T> ostream& operator << (ostream &s, vector<T> P) 
{ for (int i = 0; i < P.size(); ++i) { if (i > 0) { s << " "; } s << P[i]; } return s << endl; }
template<class T1, class T2> ostream& operator << (ostream &s, map<T1,T2> P) 
{ EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; } return s << endl; }


int n;
double w, h;

int main() {
    while ( scanf("%d,%lf,%lf", &n, &w, &h) != EOF ) {
        double bmi = w / (h * h);
        if (bmi >= 25.0) cout << n << endl;
    }
    
    return 0;
}

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

using namespace std;

int main(){
	queue<int> data;
	double bmi;
	double weight,height;
	char tmp;
	int num;
	while(cin>>num){
	//	if(num==0)break;
		cin>>tmp;
		cin>>weight;
		cin>>tmp;
		cin>>height;

		bmi = weight/(height*height);

		if(bmi >= 25.0){
			data.push(num);
		}
	}
	int size = data.size();
	for(int i=0;i<size;i++){
		cout<<data.front()<<endl;
		data.pop();
	}

	return 0;
}
/*
Sample Input
1001,50.0,1.60 
1002,60.0,1.70 
1003,70.0,1.80 
1004,80.0,1.70 
1005,90.0,1.60 
Output for the Sample Input
1004
1005 
*/