Go: package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func main() {
	sc.Split(bufio.ScanLines)
	for sc.Scan() {
		n := strings.Split(sc.Text(), ",")
		id, _ := strconv.Atoi(n[0])
		weight, _ := strconv.ParseFloat(n[1], 64)
		height, _ := strconv.ParseFloat(n[2], 64)
		bmi := weight / (height * height)
		if bmi >= 25.0 {
			fmt.Println(id)
		}
	}
}

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

using namespace std;

double BMI(double height, double weight)
{
	return weight / pow(height / 100.0, 2);
}

int main()
{
	const int DATASETS = 1000;

	int Number[DATASETS], C = 0; double H[DATASETS], W[DATASETS]; char ch;

	while (cin >> Number[C] >> ch >> H[C] >> ch >> W[C])
	{
		C++;
	}

	for (int i = 0; i < C; i++)
	{
		if (BMI(H[i], W[i] * 100.0) >= 25.0)
		{
			cout << Number[i] << endl;
		}
	}

	return 0;
}

C++: #include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<deque>
#include<set>
#include<map>
#include<algorithm>
#include<string>
#include<utility>
#include<cmath>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cctype>
using namespace std;


int main(){
	int n;
	double a,b;
	map<int,double> data;
	
	while(scanf("%d,%lf,%lf",&n,&a,&b) != EOF){
		data[n] = a/pow(b,2);
	}
	
	for(map<int,double>::iterator it = data.begin();it!=data.end();++it){
		if( it->second >= 25.0){
			printf("%d\n",it->first);
		}
	}

}

C++: #include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <string>
#include <sstream>
#include <stack>
#include <iomanip>
#include <numeric>
#include <queue>
#include <climits>
#include <set>
#include <complex>
#include <cmath>
#include <cstring>
#include <map>
using namespace std;
using ll = long long;
#define MOD 1000000007
#define INF 1LL << 59

const int maxT = 3600 * 2;
int main()
{
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    //cout << fixed << setprecision(7);

    int s;
    double w, h;
    vector<int> ans;
    while (scanf("%d,%lf,%lf", &s, &w, &h) != EOF)
    {
        if (w / (h * h) >= 25)
            ans.push_back(s);
    }

    for (auto e : ans)
        cout << e << 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].pushback(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;

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

C++: #include <cstdio>

using namespace std;

int main(){
  int n;
  double w,l;
  while(scanf("%d,%lf,%lf",&n,&w,&l)>0){
    if(w/(l*l)>=25) printf("%d\n",n);
  }
  return 0;
}

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

using namespace std;

int main() {
	vector<int> ans;
	int a;
	float 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 <string>
using namespace std;

int main(void)
{
	string str;
	while (cin >> str)
	{
		int id;
		double kg, m;
		for (int i = 0; i < str.size(); i++) if (str[i] == ',') str[i] = ' ';
		stringstream ss(str);
		ss >> id >> kg >> m;
		double bmi = kg / (m * m);
		if (bmi >= 25.0) cout << id << endl;
	}
	return 0;
}

C++: //include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <fstream>
#include <complex>
#include <math.h>

using namespace std;

//conversion
//------------------------------------------
inline long toLong(string s) {long v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}

//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}

//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long, long> PLL;
typedef long long LL;
//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 SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())

//repetition
//------------------------------------------
#define FOR(i,a,b) for(long i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

//constant
//--------------------------------------------

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

const double EPS = 1e-10;
const double INF = 1e9;



int main(){
	int num;
	double w,h;
	char c1,c2;
	vector<int>res;
	while(cin>>num>>c1>>w>>c2>>h){
		if(w>=(25.0+EPS)*(h*h))res.PB(num);
	}
	REP(i,SZ(res))cout<<res[i]<<endl;
	return 0;
}

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

using namespace std;

int main(void)
{
	int num;
	double weight, height, bmi;
	
	while(scanf("%d,%lf,%lf", &num, &weight, &height) != EOF ){
		bmi = weight / (height * height);
		if(bmi >= 25)
		cout << num << endl;
	}
	return 0;
}

C++: #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <array>
#include <queue>
#include <deque>
#include <set>
#include <list>
#include <map>
#include <stack>
#include <utility>
#include <bitset>
#include <complex>
#include <algorithm>
#include <numeric>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <climits>
#include <random>
#include <functional>
#include <sstream>
#include <iomanip>

using namespace std;

#define rep(i, n) for(int i=0; i<(n); i++)
#define FOR(i, m, n) for(int i=(m);i<(n);i++)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define SORT(x) sort((x).begin(),(x).end())
#define REVE(x) reverse((x).begin(),(x).end())
#define mp make_pair
#define pb push_back
#define Cout(x) cout << (x) << endl;
#define dump(x) cout << #x << " = " << (x) << endl;
#define forauto(i, a) for(auto i:a)cout << i << " "; puts("");

typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef complex<double> CD;

int main() {
	int s; double w, h; char c;
	while (cin >> s >> c >> w >> c >> h) {
		double bmi = w / pow(h, 2);
		if (25 <= bmi)Cout(s);
	}
}