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 <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-9;
const double INF = 1e9;



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

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

int main()
{
	int i,gakuseki,tmp=-1;
	double W,L;
	double BMI;
	while(scanf("%d,%lf,%lf",&gakuseki,&W,&L)){
		if(tmp==gakuseki)break;
        tmp=gakuseki;
		BMI=W/L/L;
	  
		if(BMI>=25)
		cout<<gakuseki<<endl;
	}
	
	return 0;
}

C++: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;

//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\b.txt"

string to_string_keta(const long long int l, const int keta) {
	ostringstream oss;

	oss << std::setw(keta) << std::setfill('0') << l;

	return oss.str();
}
int main() {
	cout << fixed << setprecision(22);
	string st;
	while (getline(cin,st)) {
		int a = st.find(',');
		int b = st.find(',',a+1);
		const int num = stoi(st.substr(0, a));
		const ld wei = stold(st.substr(a + 1, b - a - 1));
		const ld hei = stold(st.substr(b + 1));
		const ld bmi = wei / hei / hei;
		if (bmi > 25 - eps)cout << num << endl;

	}

	return 0;
}

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

int main()
{
	double num, t, w, flg;
	char ch;
	flg = 0;
	while (cin>>num>>ch>>w>>ch>>t)
	{
		if (w/(t*t)>=25)
		{
			cout << num << endl;
			flg = 1;
		}
	}
	if (flg=0)
	{
		cout << "該当なし" << endl;
	}
	return 0;
}

C++: #include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,b) FOR(i,0,b)
#define BE(c) c.begin(),c.end()
#define PB push_back
#define F first
#define S second
#define BEB(s) s
using namespace std;
int main(){
	char com;
	double BMI,b,c;
	int a;
	while(cin>>a>>com>>b>>com>>c){
		if(25<b/(c*c))cout<<a<<endl;
	}
	return 0;
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <cstring>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std;
 
#define rep(i,n) for(int i=0; i<n; i++)
#define FOR(i,s,n) for(int i=s; i<n; i++)
#define ALL(x) x.begin(), x.end()
#define pb push_back
#define foreach(it,con) for(auto it=con.begin();it!=con.end();it++)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;

struct Person{
	Person(int _id,int _m,int _h):h(_h),m(_m),id(_id){
	}
	int id;
	float m;
	float h;
	float bmi(){
		return m/h*h;
	}
};

int main(){
	int n;
	while(cin>>n){
		rep(i,n){
			int id;
			float m,h;
			cin>>id >> m >> h;
			Person p(id,m,h);
			if(p.bmi()>=25.0){
				cout << id << endl;
			}
		}
	}
	return 0;	
}

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

int main() {
  map<int, double> mp;
  int st;
  char c;
  double w, h;
  
  while(cin>>st>>c>>w>>c>>h) {
    mp[st] = w/(h*h);
  }

  for(map<int,double>::iterator it = mp.begin(); it != mp.end(); it++) {
    if((*it).second>=25.0) cout << (*it).first << endl;
  }
  
  return 0;
}

C++: #include<iostream>
#include<map>
#include<vector>
using namespace std;
int main(){
        vector<int> over;
        map<int,int> student;
        float w,h,bmi;
        int num;
        char cn,cn1;
        while(cin>>num>>cn1>>w>>cn>>h){
                h *= h;
                bmi = w / h;
                student.insert(map<int,int>::value_type(num,bmi));
        }
        map<int,int>::iterator it=student.begin();
        for(;it!=student.end();it++){
                if( (*it).second >=25) over.push_back((*it).first);
        }
        for(int i=0;i<over.size();i++) cout<<over[i]<<endl;
}

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