stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>



using namespace std;



typedef long long ll;



const int N(2e5 + 9);



int T, n, m, ans;



struct A

{

    int x, y;

    char d;

}a[N];



long double calc(long double t)

{

    long double minx = 1e19, maxx = -1e19, miny = 1e19, maxy = -1e19;

    for (int i = 0; i < n; i++)

    {

        minx = min(minx, t * (a[i].d == 'L' ? -1 : a[i].d == 'R') + a[i].x);

        maxx = max(maxx, t * (a[i].d == 'L' ? -1 : a[i].d == 'R') + a[i].x);

        miny = min(miny, t * (a[i].d == 'D' ? -1 : a[i].d == 'U') + a[i].y);

        maxy = max(maxy, t * (a[i].d == 'D' ? -1 : a[i].d == 'U') + a[i].y);

    }

    return (maxx - minx) * (maxy - miny);

}



int main()

{

    cin>>n;

    for (int i = 0; i < n; i++)

    {

        cin>>a[i].x>>a[i].y>>a[i].d;

    }

    long double l = 0, r = 1e18, midl, midr;

    for (int i = 0; i< 500; i++)

    {

        midl = (2 * l + r) / 3;

        midr = (2 * r + l) / 3;

        if (calc(midl) < calc(midr))

        {

            r = midr;

        }

        else l = midl;

    }

    cout<<fixed<<setprecision(16)<<calc(l)<<endl;



    return 0;

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

const double oo = 1e18;

 

int n, x[100100], y[100100];

char d[100100];

 

double calc(double t)

{

  double xMax = -oo, xMin = oo, yMax = -oo, yMin = oo;

  for (int i = 0; i < n; i++)

  {

    double curX = x[i], curY = y[i];

    if (d[i] == 'U') curY += t;

    else if (d[i] == 'D') curY -= t;

    else if (d[i] == 'R') curX += t;

    else curX -= t;

    xMax = max(xMax, curX);

    xMin = min(xMin, curX);

    yMax = max(yMax, curY);

    yMin = min(yMin, curY);

  }

  return (xMax - xMin) * (yMax - yMin);

}

 

int main()

{

  ios::sync_with_stdio(0);

  

  cin >> n;

  for (int i = 0; i < n; i++)

    cin >> x[i] >> y[i] >> d[i];

 

  double ans = calc(0), low = 0, high = 1e9;

  for (int turn = 0; turn < 150; turn++)

  {

    double mid1 = (low * 2 + high) / 3, v1 = calc(mid1);

    double mid2 = (low + high * 2) / 3, v2 = calc(mid2);

    if (v1 < v2) high = mid2;

    else low = mid1;

  }

 

  ans = min(ans, calc(low));

  cout << fixed << setprecision(9) << ans << endl;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#include <math.h>

using namespace std;

#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")

typedef long double ld;

typedef long long ll;



struct Point {

    ll x, y, x1 = 0, y1 = 0;

    

    Point() {}

    

    Point(ll _x, ll _y, char c) {

        x = _x;

        y = _y;

        if (c == 'U') {

            y1 = 1;

        } else if (c == 'D') {

            y1 = -1;

        } else if (c == 'R') {

            x1 = 1;

        } else {

            x1 = -1;

        }

    }

};



vector<Point> vc;



ld dist(ld t) {

    ld max_x = -1e9, max_y = -1e9, min_x = 1e9, min_y = 1e9;

    for (auto p : vc) {

        ld xx = p.x + p.x1 * t;

        ld yy = p.y + p.y1 * t;

        max_x = max(max_x, xx);

        max_y = max(max_y, yy);

        min_x = min(min_x, xx);

        min_y = min(min_y, yy);

    }

    return (max_x - min_x) * (max_y - min_y);

}



int main() {

#ifdef LOCAL

    freopen("in", "r", stdin);

    freopen("out", "w", stdout);

#endif

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    cout.precision(20);

    int n;

    cin >> n;

    for (int i = 0; i < n; ++i) {

        ll x, y;

        char c;

        cin >> x >> y >> c;

        vc.push_back(Point(x, y, c));

    }

    ld l = 0, r = 1e11;

    for (int i = 0; i < 700; ++i) {

        ld m1 = (r - l) / 3 + l;

        ld m2 = r - (r - l) / 3;

        ld a1 = dist(m1);

        ld a2 = dist(m2);

        if (a1 > a2) {

            l = m1;

        } else {

            r = m2;

        }

    }

    cout << fixed << min(dist(l), dist(r));

    return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<math.h>

#define N 100000000

#define M 100005

int main()

{

	int n;

	double x[M],y[M];

	char c[M];

	double minS=-1,S1,S2,l=0,r=N;

	double minl1=N,maxr1=-N,maxu1=-N,mind1=N,xx1,yy1,move1=0;

	double minl2=N,maxr2=-N,maxu2=-N,mind2=N,xx2,yy2,move2=N;

    scanf("%d",&n);

    for(int i=0;i<n;i++)scanf("%lf%lf %c",&x[i],&y[i],&c[i]);

    for(int k=0;k<=10000&&(move2-move1>0.00000000001);k++)

	{

		minl1=N,maxr1=-N,maxu1=-N,mind1=N;

		minl2=N,maxr2=-N,maxu2=-N,mind2=N;

        move1=(r/3+2*l/3),move2=(2*r/3+l/3);

        for(int i=0;i<n;i++)

		{

	        xx1=xx2=x[i];

			yy1=yy2=y[i];

			if(c[i]=='U')

			{

				yy1+=move1;

				yy2+=move2;

			}

			if(c[i]=='D')

			{

				yy1-=move1;

				yy2-=move2;

			}

			if(c[i]=='L')

			{

				xx1-=move1;

				xx2-=move2;

			}

			if(c[i]=='R')

			{

				xx1+=move1;

				xx2+=move2;

			}

	        if(xx1<minl1)minl1=xx1;

	        if(xx1>maxr1)maxr1=xx1;

	        if(yy1<mind1)mind1=yy1;

	        if(yy1>maxu1)maxu1=yy1;

	        if(xx2<minl2)minl2=xx2;

	        if(xx2>maxr2)maxr2=xx2;

	        if(yy2<mind2)mind2=yy2;

	        if(yy2>maxu2)maxu2=yy2;

	    }

	    S1=(maxr1-minl1)*(maxu1-mind1);

	    S2=(maxr2-minl2)*(maxu2-mind2);

        if(S1<minS||minS==-1)minS=S1;

        if(S2<minS||minS==-1)minS=S2;

        if(S1>S2)l=move1;

        else r=move2;

    }

    printf("%.10f\n",minS);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include <cstdio>

#include <cmath>

#include <algorithm>

#include <map>

#include <cstring>

#include <string>

typedef long long ll;

using namespace std;

int n,x[100005],y[100005],d[100005];

char ch[]="RLUD";

int dx[]={1,-1,0,0},dy[]={0,0,1,-1};

const unsigned int mo=1e9+7;

double ans=9e99;

bool tra(long double t,int md){

	double max=x[0]+t*dx[d[0]],mix=max,may=y[0]+t*dy[d[0]],miy=may;

	ll nmax=0,nmix=0,nmay=0,nmiy=0;

	for(int i=1;i<n;++i){

		long double X=x[i]+t*dx[d[i]],Y=y[i]+t*dy[d[i]];

		if(X>max)nmax=i,max=X;

		if(X<mix)nmix=i,mix=X;

		if(Y>may)nmay=i,may=Y;

		if(Y<miy)nmiy=i,miy=Y;

	}

	//cout<<max<<may<<mix<<miy<<endl;

	ans=min(ans,(max-mix)*(may-miy));

	int p;

	if(md&4) md-=4,p=dx[d[nmax]]-dx[d[nmix]];

	else p=dy[d[nmay]]-dy[d[nmiy]];

	return p<md-1;

}

int main(){

	scanf("%d",&n);

	for(int i=0;i<n;++i){

		char tp;

		scanf("%d%d %c",x+i,y+i,&tp);

		for(int j=0;j<4;++j){

			if(ch[j]==tp){

				//cout<<j<<endl;

				d[i]=j;break;

			}

		}

	}

	for(int mode=0;mode<8;++mode){

		long double l=0,r=2e8;

		for(int i=0;i<130;++i){

			double mid=(l+r)/2;

			//printf("%.39lf\n",mid);

			if(tra(mid,mode))l=mid;

			else r=mid;

			//printf("%.39lf\n",(double)ans);

		}

	}

	printf("%.17lf\n",ans);

	return 0;

} 

/*

3

-1000 0 U

1000 0 L

-1900 0 R

*/

// Optimized solution to the same problem (faster):
#include<iostream>

#include <cstdio>

#include <cmath>

#include <algorithm>

#include <map>

#include <cstring>

#include <string>

typedef long long ll;

using namespace std;

int n,x[100005],y[100005],d[100005];

char ch[]="RLUD";

int dx[]={1,-1,0,0},dy[]={0,0,1,-1};

const unsigned int mo=1e9+7;

double ans=9e99;

bool tra(long double t,int md){

	double max=x[0]+t*dx[d[0]],mix=max,may=y[0]+t*dy[d[0]],miy=may;

	ll nmax=0,nmix=0,nmay=0,nmiy=0;

	for(int i=1;i<n;++i){

		long double X=x[i]+t*dx[d[i]],Y=y[i]+t*dy[d[i]];

		if(X>max)nmax=i,max=X;

		if(X<mix)nmix=i,mix=X;

		if(Y>may)nmay=i,may=Y;

		if(Y<miy)nmiy=i,miy=Y;

	}

	//cout<<max<<may<<mix<<miy<<endl;

	ans=min(ans,(max-mix)*(may-miy));

	int p;

	if(md&4) md-=4,p=dx[d[nmax]]-dx[d[nmix]];

	else p=dy[d[nmay]]-dy[d[nmiy]];

	return p<md-1;

}

int main(){

	scanf("%d",&n);

	for(int i=0;i<n;++i){

		char tp;

		scanf("%d%d %c",x+i,y+i,&tp);

		for(int j=0;j<4;++j){

			if(ch[j]==tp){

				//cout<<j<<endl;

				d[i]=j;break;

			}

		}

	}

	for(int mode=0;mode<8;++mode){

		long double l=0,r=2e8;

		for(int i=0;i<70;++i){

			double mid=(l+r)/2;

			//printf("%.39lf\n",mid);

			if(tra(mid,mode))l=mid;

			else r=mid;

			//printf("%.39lf\n",(double)ans);

		}

	}

	printf("%.17lf\n",ans);

	return 0;

} 

/*

3

-1000 0 U

1000 0 L

-1900 0 R

*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

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

#define double long double

#define int long long

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

using namespace std;

typedef pair<int, int> P;

const int mod = 1000000007;

const int INF = 1e18;



double dx[4] = { 0, 1, 0, -1};

double dy[4] = {-1, 0, 1, 0};

string dir = "DRUL";



int n;

vector<double> x, y;

vector<char> d;



// double xx[4] = {}

// double yy[4] = {INF, 0, INF, 0}



double calc(double m){

    double MAXy = -INF, MAXx = -INF;

    double MINy = INF, MINx = INF;

    rep(i, 0, n){

        int idx = dir.find(d[i]);

        double nx = x[i] + m * dx[idx];

        double ny = y[i] + m * dy[idx];

        chmax(MAXx, nx);

        chmax(MAXy, ny);

        chmin(MINx, nx);

        chmin(MINy, ny);

    }

    return (MAXx - MINx) * (MAXy - MINy);

}



signed main(){

    cin >> n;

    x.resize(n); y.resize(n); d.resize(n);

    rep(i, 0, n){

        cin >> x[i] >> y[i] >> d[i];

        // int idx = dir.find(d[i]);

        // if(idx == 0){



        // }else if(idx == 1){



        // }else if(idx == 2){

            

        // }else{



        // }

    }

    double l = 0, r = 1e9;

    double MIN = INF;

    rep(i, 0, 200){

    // while(fabs(r - l) > 1e-10){

        double m1 = (l * 2 + r) / 3;

        double m2 = (l + r * 2) / 3;

        double t1 = calc(m1);

        double t2 = calc(m2);

        if(t1 < t2) r = m2;

        else l = m1;

        chmin(MIN, t1);

        chmin(MIN, t2);

    }

    printf("%.10Lf\n", MIN);

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

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

#define int long long

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

using namespace std;

typedef pair<int, int> P;

const int mod = 1000000007;

const int INF = 1e18;



double dx[4] = { 0, 1, 0, -1};

double dy[4] = {-1, 0, 1, 0};

string dir = "DRUL";



int n;

vector<double> x, y;

vector<char> d;



// double xx[4] = {}

// double yy[4] = {INF, 0, INF, 0}



double calc(double m){

    double MAXy = -INF, MAXx = -INF;

    double MINy = INF, MINx = INF;

    rep(i, 0, n){

        int idx = dir.find(d[i]);

        double nx = x[i] + m * dx[idx];

        double ny = y[i] + m * dy[idx];

        chmax(MAXx, nx);

        chmax(MAXy, ny);

        chmin(MINx, nx);

        chmin(MINy, ny);

    }

    return (MAXx - MINx) * (MAXy - MINy);

}



signed main(){

    cin >> n;

    x.resize(n); y.resize(n); d.resize(n);

    rep(i, 0, n){

        cin >> x[i] >> y[i] >> d[i];

    }

    double l = 0, r = 1e9;

    double MIN = INF;

    rep(i, 0, 200){

    // while(fabs(r - l) > 1e-10){

        double m1 = (l * 2 + r) / 3;

        double m2 = (l + r * 2) / 3;

        double t1 = calc(m1);

        double t2 = calc(m2);

        if(t1 < t2) r = m2;

        else l = m1;

        chmin(MIN, t1);

        chmin(MIN, t2);

    }

    printf("%.10f\n", MIN);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string>

#include<algorithm>

#include<cstdlib>

template<typename T>

void fin(T const& t){ std::cout << t << std::endl; exit(0); }



int const MAXL = 2000;



bool ngAC[MAXL*5], ngBC[MAXL*5];



int main() {

  std::string a, b, c; std::cin >> a >> b >> c;

  int aL = a.size(), bL = b.size(), cL = c.size();

  int mL = std::max(aL, std::max(bL, cL));

  std::fill_n(ngAC, MAXL*5, false);

  std::fill_n(ngBC, MAXL*5, false);

  for(int i = 0; i < aL; ++i) for(int j = 0; j < cL; ++j) {

    if(a[i]!='?' && c[j]!='?' && a[i]!=c[j]) ngAC[MAXL*2+i-j] = true;

  }

  for(int i = 0; i < bL; ++i) for(int j = 0; j < cL; ++j) {

    if(b[i]!='?' && c[j]!='?' && b[i]!=c[j]) ngBC[MAXL*2+i-j] = true;

  }

  

  int ans = aL+bL+cL;

  for(int ob = -MAXL*2; ob < MAXL*2; ++ob) {

    int bl = std::min(0, ob), br = std::max(aL, ob+bL);

    if(br - bl > ans) continue;

    // check AB match

    bool ok = true;

    for(int x = std::max(0, ob); x < std::min(aL, ob+bL); ++x) {

      if(a[x]!='?' && b[x-ob]!='?' && a[x]!=b[x-ob]) { ok = false; break; }

    }

    if(!ok) continue;

    for(int oc = -MAXL*2; oc < MAXL*2; ++oc) {

      int cl = std::min(bl, oc), cr = std::max(br, oc+cL);

      if(cr - cl > ans) continue;

      if(ngAC[MAXL*2+oc]) continue;

      if(ngBC[MAXL*2+oc-ob]) continue;

      ans = cr - cl;

    }

  }

  fin(ans);

  return 0;

}


// Optimized solution to the same problem (faster):
#include<iostream>

#include<string>

#include<algorithm>

#include<cstdlib>

template<typename T>

void fin(T const& t){ std::cout << t << std::endl; exit(0); }



int const MAXL = 2000;



bool ngAC[MAXL*5], ngBC[MAXL*5];



int main() {

  std::string a, b, c; std::cin >> a >> b >> c;

  int aL = a.size(), bL = b.size(), cL = c.size();

  int mL = std::max(aL, std::max(bL, cL));

  std::fill_n(ngAC, MAXL*5, false);

  std::fill_n(ngBC, MAXL*5, false);

  for(int i = 0; i < aL; ++i) for(int j = 0; j < cL; ++j) {

    if(a[i]!='?' && c[j]!='?' && a[i]!=c[j]) ngAC[MAXL*2+i-j] = true;

  }

  for(int i = 0; i < bL; ++i) for(int j = 0; j < cL; ++j) {

    if(b[i]!='?' && c[j]!='?' && b[i]!=c[j]) ngBC[MAXL*2+i-j] = true;

  }

  

  int ans = aL+bL+cL;

  for(int ob = -bL-cL; ob < aL+cL; ++ob) {

    int bl = std::min(0, ob), br = std::max(aL, ob+bL);

    if(br - bl > ans) continue;

    // check AB match

    bool ok = true;

    for(int x = std::max(0, ob); x < std::min(aL, ob+bL); ++x) {

      if(a[x]!='?' && b[x-ob]!='?' && a[x]!=b[x-ob]) { ok = false; break; }

    }

    if(!ok) continue;

    for(int oc = -bL-cL; oc < aL+bL; ++oc) {

      int cl = std::min(bl, oc), cr = std::max(br, oc+cL);

      if(cr - cl > ans) continue;

      if(ngAC[MAXL*2+oc]) continue;

      if(ngBC[MAXL*2+oc-ob]) continue;

      ans = cr - cl;

    }

  }

  fin(ans);

  return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <vector>

#include <algorithm>

#include <string>

#include <map>

#include <cmath>

#include <queue>

#include <numeric>

#include <climits>

#include <iterator>

#include <iomanip>

#include <stack>

#include <bitset>

#include <functional>

using namespace std;

const constexpr int INF = 1e9;

//typedef std::pair<std::string,double> P;



typedef long long ll;

typedef vector<int> VI;



#define FOR(i, a, n) for (ll i = (ll)a; i<(ll)n; ++i)

#define REP(i, n) FOR(i, 0, n)



//グラフの隣接リスト

VI g[200010];

//頂点の入次数を管理

int h[100010];

ll N;



int a[200010];

int b[200010];

int c[200010];

ll sum[200010];

signed main(void) {

    cin >> N;

    vector<int> ans;

    int maxn=1;

    while(maxn*(maxn+1)/2<N) maxn++;

    for(int i=1; i<=maxn; ++i){

        if(i!=(maxn+1)*maxn/2-N) printf("%d\n", i);

    }

	return 0;

}


// Optimized solution to the same problem (faster):
#include <iostream>

#include <string>

#include <vector>

#include <set>

#include <cmath>

#include <stack>

#include <algorithm>

#include <iomanip>

#include <map>

#include <queue>

#include <functional>

#include <numeric>

#include <chrono>

using ll = long long;

using namespace std;



const ll MOD = 1e9 + 7;

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

// bool operator<(const pair<int, int> &a, const pair<int, int> &b)

// {

//     if (a.first == b.first)

//         return a.second < b.second;

//     return a.first < b.first;

// };



/*unsigned int xor128(void)

{

    static unsigned int x = 123456789, y = 362436069, z = 521288629, w = 88675123;

    unsigned int t = (x ^ (x << 11));

    x = y;

    y = z;

    z = w;

    return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));

}

unsigned int xor128rnd(unsigned int m)

{

    return xor128() % m;

}*/

vector<vector<string>> v(27);



vector<pair<int, int>> vp;

int main(void)

{

    int N;

    cin >> N;

    vector<int> ans;

    int maxn = 1;

    while (maxn * (maxn + 1) / 2 < N)

        maxn++;

    for (int i = 1; i <= maxn; ++i)

    {

        if (i != (maxn + 1) * maxn / 2 - N)

            printf("%d\n", i);

    }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

#define _GLIBCXX_DEBUG

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

#define rep2(i, N, a, b) for(int i = a; i < N; i += b)



int main(){

	string S;

	cin >> S;



	char prev = ' ';

	int cnt = 0;

	bool two = false;

	rep(i, (int)(S.size())){

		if (two == true) two = false;

		else if (S[i] == prev){

			if (i == (int)(S.size()) - 1) break ;

			two = true;

			i++;

		}

		prev = S[i];

		cnt++;

	}

	cout << cnt << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>



int		main(){

	char S[200001];

	// char *S;

	// S = (char *)calloc(30000, sizeof(char));

	scanf("%s\n", S);

	// S[strlen(S)] = '\0';

	char prev = ' ';

	int cnt = 0;

	int flag = 0;

	for (int i  = 0; i < strlen(S); i++){

		// printf("%s\n", prev);

		if (flag == 1 || S[i] != prev)

			flag = 0;

		else if (i == strlen(S) - 1) cnt--;

		else {

			flag = 1;

			i++;

		}

		prev = S[i];

		cnt++;

	}

	printf("%d\n", cnt);

	return (0);

}



// int		main(){

// 	char S[10001];

// 	scanf("%s\n", S);

// 	S[strlen(S)] = '\0';

// 	char prev[10001];

// 	// printf("%s\n", S);

// 	int cnt = 0;

// 	for (int i  = 0; i < strlen(S); i++){

// 		// printf("%s\n", prev);

// 		cnt++;

// 		prev[0] = S[i];

// 		if (strlen(prev) > 1 || S[i] != prev[0])

// 			prev[1] = '\0';

// 		else if (i != strlen(S) - 1){

// 			prev[1] = S[++i];

// 			prev[2] = '\0';

// 		}

// 	}

// 	printf("%d\n", cnt);

// 	return (0);

// }



// if (strlen(prev) > 1 || S[i] != prev[0]){

// 			cnt++;

// 			prev[0] = S[i];

// 			prev[1] = '\0';

// 		}

// 		else if (i == strlen(S) - 1) break ;

// 		else {

// 			cnt++;

// 			prev[0] = S[i];

// 			prev[1] = S[++i];

// 			prev[2] = '\0';

// 		}

// 	}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <algorithm>

#include <string>

#include <cstring>



using namespace std;

int main() {

	char str[100];

	int cnt[130] = { 0 };

	cin >> str;

	int len = strlen(str);

	for (int i = 0; i <len; i++) {

		int k = (int)(str[i] - 'a');

		cnt[k]++;

		if (cnt[k] > 1) {

			cout << "no" << endl;

			system("pause");

			return 0;

		}

	}

	cout << "yes" << endl;





	system("pause");

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<cstring>

#include<string>



using namespace std;



char w[27];

int flag[27];

int vis;



int main()

{

	scanf("%s",w);

	int len = strlen(w);

	for(int i = 0;i < len;i++){

		flag[w[i]-'a' + 1] ++;

	}

	for(int i = 1;i <= 26;i++){

		if(flag[i] != 1 && flag[i] != 0) vis = 1;

	}

	if(vis == 1) printf("no\n");

	else printf("yes\n");

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

char s[10000],c;

int main(){

	scanf("%s",s);

	int len=strlen(s);

	for(int i=0;i<len;i++)

		for(int j=i+1;j<len;j++)

			if(s[i]==s[j]){

				printf("no");

				return 0;

			}

	printf("yes");

}

// Optimized solution to the same problem (faster):
#include <cstdio>

int a[40],b;

char S[40];

int main ()

{

	scanf ("%s",S);

	for (b=0;S[b];b++) a[S[b]-'a']++;

	for (b=0;b<26;b++) b=a[b]>1?27:b;

	printf ("%s\n",b==26?"yes":"no");

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>

using namespace std;

int y[101],r,n;



bool check(double cy){

  double x=sqrt(r*r-cy*cy);

  if(cy>=0)x=r;

  int L=(-x-0.9999),R=(x+0.9999),hb[101]={};



  for(int i=L+50;i<R+50;i++){

    int x1=i-49-i/50;

    double y1=y[i]-cy;

    if(sqrt(x1*x1+y1*y1)>=r)hb[i]++;

  }

  for(int i=L+50;i<R+50;i++)if(!hb[i])return 0;

  return 1;

}



int main(){

  while(1){

    cin>>r>>n;

    if(!r&&!n)break;

    for(int i=0;i<100;i++)y[i]=0;



    for(int i=0;i<n;i++){

      int x1,x2,h;

      cin>>x1>>x2>>h;

      for(int j=x1;j<x2;j++) y[j+50]=max(y[j+50],h);

    }

    double ans=0;

    while(check(ans-r))ans+=0.0005;

    cout << ans-0.0005<<endl;

  }

  return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <cmath>

using namespace std;

int y[50],r,n;



bool check(double cy){

  double x=sqrt(r*r-cy*cy);

  if(cy>=0)x=r;

  int L=-x-0.9999,R=x+0.9999,hb[101]={};



  for(int i=L+25;i<R+25;i++){

    int x1=i-24-i/25;

    double y1=y[i]-cy;

    if(x1*x1+y1*y1>=r*r)hb[i]++;

  }

  for(int i=L+25;i<R+25;i++)if(!hb[i])return 0;

  return 1;

}



int main(){

  while(1){

    cin>>r>>n;

    if(!r&&!n)break;

    for(int i=0;i<50;i++)y[i]=0;



    for(int i=0;i<n;i++){

      int x1,x2,h;

      cin>>x1>>x2>>h;

      for(int j=x1;j<x2;j++) y[j+25]=max(y[j+25],h);

    }

    double ans=0;

    while(check(ans-r))ans+=0.0009;

    cout << ans<<endl;

  }

  return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>

using namespace std;

int y[101],r,n;



bool check(double cy){

  double x=sqrt(r*r-cy*cy);

  if(cy>=0)x=r;

  int L=(-x-0.9999),R=(x+0.9999),hb[101]={};



  for(int i=L+50;i<R+50;i++){

    int x1=i-49-i/50;

    double y1=y[i]-cy;

    if(sqrt(x1*x1+y1*y1)>=r)hb[i]++;

  }

  for(int i=L+50;i<R+50;i++)if(!hb[i])return 0;

  return 1;

}



int main(){

  while(1){

    cin>>r>>n;

    if(!r&&!n)break;

    for(int i=0;i<100;i++)y[i]=0;



    for(int i=0;i<n;i++){

      int x1,x2,h;

      cin>>x1>>x2>>h;

      for(int j=x1;j<x2;j++) y[j+50]=max(y[j+50],h);

    }

    double ans=0;

    while(check(ans-r))ans+=0.0009;

    cout << ans<<endl;

  }

  return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <cmath>

using namespace std;

int y[50],r,n;



bool check(double cy){

  double x=sqrt(r*r-cy*cy);

  if(cy>=0)x=r;

  int L=-x-0.9999,R=x+0.9999,hb[101]={};



  for(int i=L+25;i<R+25;i++){

    int x1=i-24-i/25;

    double y1=y[i]-cy;

    if(x1*x1+y1*y1>=r*r)hb[i]++;

  }

  for(int i=L+25;i<R+25;i++)if(!hb[i])return 0;

  return 1;

}



int main(){

  while(1){

    cin>>r>>n;

    if(!r&&!n)break;

    for(int i=0;i<50;i++)y[i]=0;



    for(int i=0;i<n;i++){

      int x1,x2,h;

      cin>>x1>>x2>>h;

      for(int j=x1;j<x2;j++) y[j+25]=max(y[j+25],h);

    }

    double ans=0;

    while(check(ans-r))ans+=0.0009;

    cout << ans<<endl;

  }

  return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<stdio.h>

#include<iostream>

#include<math.h>

#include<cstring>

#include<algorithm> 

using namespace std;



int main()

{

	int s,w;

	cin>>s>>w;

	if(s<=w)

		cout<<"unsafe";

	else

		cout<<"safe"; 

}

 

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

          int a,b;

          scanf("%d%d",&a,&b);

          if(b>=a)

                    printf("unsafe\n");

          else

                    printf("safe\n");

          return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

using namespace std;

int main(){



    int S, W;

    cin>> S;

    cin>> W;



    if(W >= S){

        cout<< "unsafe" <<endl;

    }

    else{

        cout<< "safe" <<endl;

    }



    return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

          int a,b;

          scanf("%d%d",&a,&b);

          if(b>=a)

                    printf("unsafe\n");

          else

                    printf("safe\n");

          return 0;

}


// Fastest known solution for this problem: