akhauriyash/Code-Regression huggingface dataset:
#include <iostream>

int main()
{
    long num[5];
    std::cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4];
    for (int i : num) {
        if (num[i] == 0) {
            std::cout << i + 1 << std::endl;
            break;
        }
    }
}

Measured memory_bytes: 3152
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <vector>
#include <queue>
using namespace std;

int n;
int ban[100010];

priority_queue <int, vector <int>, greater<int> > q;
int ans[100010];


vector <int> rem;

void dfs (int num) {
	if (num >= n - 9) {
		rem.resize(0);
		int last = ans[num - 1];
		while (!q.empty()) {
			rem.push_back(q.top());
			q.pop();
		}
		do {
			bool check = true;
			check &= (ban[last] != rem[0]);
			for (int i = 1; i < rem.size(); i ++)
				check &= (ban[rem[i - 1]] != rem[i]);
			if (check) {
				// for (int i = 1; i <= n; i ++)
					// cout << ban[i] << " ";
				// cout << " : ";
				for (int i = 0; i < num; i ++)
					cout << ans[i] << " ";
				for (int i = 0; i < rem.size(); i ++)
					cout << rem[i] << " ";
				cout << endl;
				
				exit(0) ;
			}
		} while (next_permutation (rem.begin(), rem.end()));
		if (num == n - 9) {
			// cerr << "in charge " << endl;
			for (int i = 0; i < rem.size(); i ++)
				if (rem[i] != ban[ans[num - 1]])
					q.push(rem[i]);
			int beg = num - 1;
			while (beg >= 0 && ban[ans[beg]] == ban[ans[num - 1]]) {
				q.push(ans[beg]);
				beg --;
			}
			// cerr << "beg = " << beg << endl;
			ans[beg + 1] = ban[ans[num - 1]];
			dfs (beg + 2);
			exit(0);
		}
		cout << -1 << endl;
		exit(0);
	}
	if (num == 0) {
		ans[num] = 1;
		q.pop();
		dfs (num + 1);
		return ;
	}
	int c = q.top();
	if (ban[ans[num - 1]] != c) {
		ans[num] = c;
		q.pop();
		dfs (num + 1);
	}
	else {
		q.pop();
		int c2 = q.top();
		ans[num] = c2;
		q.pop();
		q.push(c);
		dfs (num + 1);
	}
}


int main() {
	ios::sync_with_stdio(false);
	cin >> n;
	for (int i = 1; i <= n; i ++) {
		cin >> ban[i];
		q.push(i);
	}
	dfs (0);
	// int st = 0;
	// do {
	// 	n = 6;
	// 	st ++;
	// 	int ed = st;
	// 	for (int i = 1; i <= n; i ++) {
	// 		ban[i] = ed % 6 + 1;
	// 		ed /= 6;
	// 		q.push (i);
	// 	}
	// 	dfs (0);
	// } while (st < 6 * 6 * 6 * 6 * 6 * 6);


	return 0;
}

Measured memory_bytes: 20856
#include <cstdio>
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>

#ifdef _DEBUG
#define DMP(x) cerr << #x << ": " << x << "\n"
#else
#define DMP(x) ((void)0)
#endif

const int MOD = 1000000007, INF = 1111111111; 
using namespace std;
using lint = long long;

int main() {

	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	int N;
	cin >> N;

	vector<pair<lint, lint>> A(N);
	for (int i = 0; i < N; i++) cin >> A[i].second >> A[i].first;
	sort(A.begin(), A.end());

	bool flag = true;
	lint cnt = 0;
	for (int i = 0; i < N; i++) {

		cnt += A[i].second;
		if (cnt > A[i].first) {
			flag = false;
			break;
		}
	}

	if (flag) cout << "Yes" << "\n";
	else cout << "No" << "\n";

	return 0;
}

Measured memory_bytes: 3328
def CountingSort(A, k):
    C = [0] * k
    B = C[:]
    for a in A:
        C[a] += 1
    for i in range(1, len(C)):
        C[i] += C[i - 1]
    for i in range(len(A) - 1, -1, -1):
        B[C[A[i]]] = A[i]
        C[A[i]] -= 1
    return B



if __name__ == '__main__':
    N = int(input())
    A = [int(i) for i in input().strip().split()]
    sorted_A = CountingSort(A, int(3E6))
    print(' '.join([str(a) for a in sorted_A[1:len(A) + 1]]))

Measured memory_bytes: 260012
x,y,z,k = [int(num) for num in input().split()]
a_cake,b_cake,c_cake = [sorted([int(num) for num in input().split()],reverse=True)[:k] for _ in range(3)]

sum_cake=list()
for i,a in enumerate(a_cake,1):
    for j,b in enumerate(b_cake,1):
        if(i*j>k):
            break
        for n,c in enumerate(c_cake,1):
            if(i*j*n>k):
                break
            sum_cake.append(a+b+c)


sum_cake.sort(reverse=True)

for i in sum_cake[:k]:
    print(i)




Measured memory_bytes: 8692
#include<iostream>
#include<cstdio>
#include <stdio.h>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<map>
#include<vector>
#include <set>
#define ll long long
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
using namespace std;
int  sum;
int main()
{
    IO;
    int l,r,d;
    cin>>l>>r>>d;
    for(int i=d;i<500;i+=d)
    {
        if(l<=i&&i<=r)
        {
            sum++;
        }
    }

    cout<<sum<<endl;
    return 0;
}


Measured memory_bytes: 3648
# A - Still TBD
import datetime
s=input()
y,m,d=s.split("/")
d1=datetime.datetime(year=2019,month=4,day=30)
d2=datetime.datetime(year=int(y),month=int(m),day=int(d))

if d1<d2:
    print("TBD")
else:
    print("Heisei")



Measured memory_bytes: 3312
#include <bits/stdc++.h>
using namespace std;

#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple

using uint=unsigned;
using ll=long long;
using ull=unsigned long long;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using vd=vector<double>;
using vvd=vector<vd>;
using vs=vector<string>;

template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
	return os<<'('<<p.first<<','<<p.second<<')';
}

template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
	print_tuple<Cdr...>(os,t);
	os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
	print_tuple<Args...>(os<<'(',t);
	return os<<')';
}

template<typename Ch,typename Tr,typename C>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
	os<<'[';
	for(auto i=begin(c);i!=end(c);++i)
		os<<(i==begin(c)?"":" ")<<*i;
	return os<<']';
}

constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;

int main()
{
	for(int n,p;cin>>n>>p&&n|p;){
		vi a(n);
		rep(i,n) cin>>a[i];

		vvl dp(n+1,vl(2));
		dp[0][0]=1;
		rep(i,n) rep(j,2){
			dp[i+1][j]+=dp[i][j];
			dp[i+1][j+a[i]&1]+=dp[i][j];
		}
		cout<<dp[n][p]<<endl;
	}
}


Measured memory_bytes: 256
#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <string>
#include <stdio.h>

using namespace std;

int main(){
	
	int A,B,C;
	cin >> A >> B >> C;

	string ans;
	if(A == B && B == C){
		ans = "Yes";
	}
	else ans = "No";

	cout << ans << endl;

	return 0;
}

Measured memory_bytes: 256
#include<iostream>
using namespace std;
int main(){
	int n,p[20],ans=0;
	cin>>n;
	for(int i=0;i<n;i++)cin>>p[i];
	for(int i=1;i<n-1;i++){
		ans+= p[i]>p[i-1]&&p[i]<p[i+1]||p[i]>p[i+1]&&p[i]<p[i-1];
	}
	cout<<ans;
	return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <climits>
#include <math.h>
using namespace std;

typedef long long ll;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<long long> vll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<vector<bool>> vvb;
typedef vector<vector<int>> vvi;

#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define all(a) a.begin(),a.end()

int main() {
	int hoge, g, b;
	cin >> hoge >> g >> b;
	if ((10 * g + b) % 4 == 0) {
		cout << "YES" << endl;
	}
	else {
		cout << "NO" << endl;
	}
	return 0;
}


Measured memory_bytes: 256
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using static System.Math;
using System.Text;
using System.Threading;
using System.Globalization;
using System.Runtime.CompilerServices;
using Library;

namespace Program
{
    public static class DDCC2020_QUALD
    {
        static public int numberOfRandomCases = 0;
        static public void MakeTestCase(List<string> _input, List<string> _output, ref Func<string[], bool> _outputChecker)
        {
        }
        static public void Solve()
        {
            var M = NN;
            var dc = Repeat(0, M).Select(_ => Tuple.Create(NN, NN)).ToList();
            Console.WriteLine((dc.Sum(e => e.Item1 * e.Item2) - 1) / 9 + dc.Sum(e => e.Item2) - 1);
        }
        static class Console_
        {
            static Queue<string> param = new Queue<string>();
            public static string NextString() { if (param.Count == 0) foreach (var item in Console.ReadLine().Split(' ')) param.Enqueue(item); return param.Dequeue(); }
        }
        class Printer : StreamWriter
        {
            public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
            public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { base.AutoFlush = false; }
            public Printer(Stream stream, Encoding encoding) : base(stream, encoding) { base.AutoFlush = false; }
        }
        static public void Main(string[] args) { if (args.Length == 0) { Console.SetOut(new Printer(Console.OpenStandardOutput())); } var t = new Thread(Solve, 134217728); t.Start(); t.Join(); Console.Out.Flush(); }
        static long NN => long.Parse(Console_.NextString());
        static double ND => double.Parse(Console_.NextString());
        static string NS => Console_.NextString();
        static long[] NNList(long N) => Repeat(0, N).Select(_ => NN).ToArray();
        static double[] NDList(long N) => Repeat(0, N).Select(_ => ND).ToArray();
        static string[] NSList(long N) => Repeat(0, N).Select(_ => NS).ToArray();
        static IEnumerable<T> OrderByRand<T>(this IEnumerable<T> x) => x.OrderBy(_ => xorshift);
        static long Count<T>(this IEnumerable<T> x, Func<T, bool> pred) => Enumerable.Count(x, pred);
        static IEnumerable<T> Repeat<T>(T v, long n) => Enumerable.Repeat<T>(v, (int)n);
        static IEnumerable<int> Range(long s, long c) => Enumerable.Range((int)s, (int)c);
        static uint xorshift { get { _xsi.MoveNext(); return _xsi.Current; } }
        static IEnumerator<uint> _xsi = _xsc();
        static IEnumerator<uint> _xsc() { uint x = 123456789, y = 362436069, z = 521288629, w = (uint)(DateTime.Now.Ticks & 0xffffffff); while (true) { var t = x ^ (x << 11); x = y; y = z; z = w; w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)); yield return w; } }
    }
}
namespace Library {
}


Measured memory_bytes: 29352
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template<class T> using V = vector<T>;
template<class T> using VV = vector<vector<T> >;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define repb(i, n) for(ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for(ll i = (a); i < (b); i++)
#define reprb(i, a, b) for(ll i = (b)-1; i >= (a); i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
const ll MOD = 1000000007;
const ll INF = 100000000000000000LL;
inline ll GCD(ll a, ll b){ return b?GCD(b, a % b):a; }
inline ll LCM(ll a, ll b){ return a/GCD(a, b)*b; }
inline ll powint(unsigned long long x, ll y){ ll r=1; while(y){ if(y&1) r*=x; x*=x; y>>=1; } return r; }
inline ll powmod(ll x, ll y, ll m = MOD){ ll r=1; while(y){ if(y&1) r*=x; x*=x; r%=m; x%=m; y>>=1; } return r; }
template<class T>bool chmax(T &a, const T &b){ if(a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a) { a=b; return 1; } return 0; }
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif

vvll dp(101, vll(100000, 0));

int main(){
    cin.tie(0); ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    ll n, W;
    cin >> n >> W;
    vll weight(n), value(n);
    rep(i, n){
        cin >> weight[i] >> value[i];
    }
    map<ll, ll> mp;
    vll pm;
    rep(i, n+1)repr(j, i*weight[0], i*weight[0]+i*3+1){
        if(!mp.count(j)){
            mp.emplace(j, SZ(pm));
            pm.emplace_back(j);
        }
    }
    auto it = upper_bound(ALL(pm), W);
    ll x, y;
    if(it == pm.begin()){
        x = y = 0;
    }else{
        --it;
        x = *it;
        y = it-pm.begin();
    }
    for (ll i = 0; i < n; ++i) {
        for (ll j = 0; j <= y; ++j) {
            ll w = pm[j];
            if(w >= weight[i]){
                if(mp.count(w-weight[i])){
                    dp[i+1][j] = max(dp[i][mp[w-weight[i]]] + value[i], dp[i][j]);
                }else{
                    dp[i+1][j] = max(dp[i+1][j-1], dp[i][j]);
                }
            }
            else dp[i+1][j] = dp[i][j];
        }
    }
    dump(pm);
    dump(mp);
    dump(x);
    dump(y);
    rep(i, n+1) dump(i, dp[i]);
    cout << dp[n][y] << endl;
    return 0;
}

Measured memory_bytes: 80496
#include <bits/stdc++.h>
using namespace std;



long long gcd(long long a,long long b){
    if (a < b) swap(a,b);
    if (b == 0) return a;
    else return gcd(a%b,b);
}

int main(){
  int n;
  cin >> n;
  vector<long long> a(n),L(n),R(n);
  for (int i = 0;i < n;i++) cin >> a[i];

  for (int i = 0;i < n-1;i++){
    L[i+1] = gcd(L[i],a[i]); 
  }

  for (int i = n-1;i > 0;i--){
    R[i-1] = gcd(R[i],a[i]);
  }

  long long ans = 1;

  for (int i = 0;i < n;i++){
    ans = max(ans,gcd(L[i],R[i]));
  }

  cout << ans << endl;
}

Measured memory_bytes: 2560
#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<int> r(3);

    for (int i = 0; i < 3; i++) {
        cin >> r.at(i);
    }

    sort(r.begin(), r.end());

    cout << r.at(0) << ' ' << r.at(1) << ' ' << r.at(2);

    cout << endl;
}


Measured memory_bytes: 3160
using System;
using System.Collections.Generic;
using System.Linq;
using static Input;

public class Prog
{
    private const int INF = 1000000007;
    public static void Main()
    {
        SieveOfEratosthenes sieve = new SieveOfEratosthenes(100000);
        sieve.Run();
        int[] q = new int[100010];
        for (int i = 1; i <= 100000; i++)
        {
            if (sieve.IsPrime(i) && sieve.IsPrime((i + 1) / 2)) q[i] = q[i - 1] + 1;
            else q[i] = q[i - 1];
        }
        int Q = NextInt();
        for (int i = 0; i < Q; i++)
        {
            int a = NextInt() - 1, b = NextInt();
            Console.WriteLine(q[b]-q[a]);
        }
    }
}
public class SieveOfEratosthenes
{
    public HashSet<int> list { get; private set; } = new HashSet<int>();
    private static bool[] memo;
    private int M, root;
    public SieveOfEratosthenes(int N)
    {
        M = (int)Math.Ceiling((double)N / 2);
        root = (int)Math.Ceiling((Math.Sqrt(N) + .1)) / 2;
        memo = new bool[M];
    }
    public void Run()
    {
        memo[0] = false;
        for (int i = 1; i < M; i++) memo[i] = true;
        list.Add(2);
        for (int i = 1; i < root; i++)
        {
            if (!memo[i]) continue;
            for (int j = 2 * i * (i + 1); j < M; j += (2 * i + 1)) memo[j] = false;
        }
        for (int i = 0; i < M; i++) if (memo[i]) list.Add(i * 2 + 1);
    }
    public bool IsPrime(int N)
    {
        return list.Contains(N);
    }
}

public class Input
{
    private static Queue<string> q = new Queue<string>();
    private static void Confirm() { if (q.Count == 0) foreach (var s in Console.ReadLine().Split(' ')) q.Enqueue(s); }
    public static int NextInt() { Confirm(); return int.Parse(q.Dequeue()); }
    public static long NextLong() { Confirm(); return long.Parse(q.Dequeue()); }
    public static string NextString() { Confirm(); return q.Dequeue(); }
    public static double NextDouble() { Confirm(); return double.Parse(q.Dequeue()); }
    public static int[] LineInt() { return Console.ReadLine().Split(' ').Select(int.Parse).ToArray(); }
    public static long[] LineLong() { return Console.ReadLine().Split(' ').Select(long.Parse).ToArray(); }
    public static string[] LineString() { return Console.ReadLine().Split(' ').ToArray(); }
    public static double[] LineDouble() { return Console.ReadLine().Split(' ').Select(double.Parse).ToArray(); }
}

Measured memory_bytes: 16824
#include <bits/stdc++.h>
//#include <Rem>
using namespace std;

long long n,a,b,sum,z,ans;

int main()
{
    scanf("%lld %lld %lld",&n,&a,&b);
    for(int i=1; i<=n; i++)
    {
        sum=0;
        z=i;
        for(;z>0;z/=10)
            sum+=z%10;
        if(a<=sum && sum<=b)
            ans+=i;
    }
    printf("%lld\n",ans);
    return 0;
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;

int main(){
  vector<int> a(5);
  for(int i = 0; i < 5; i++){
    cin >> a[i];
  }
  
  for(int i = 0; i < 5; i++){
    if(a[i] == 0){
      cout << i+1 << endl;
      break;
    }
  }
}

Measured memory_bytes: 3592
#include <bits/stdc++.h>
using namespace std;

int main() {
    int N, K, X, Y, Z;
    cin >> N >> K >> X >> Y;
  
    for (int i = 0; i < N; i++) {
        if (i < K) {
             Z += X;
        }
        else if (i >= K) {
             Z += Y;
        } 
        }
        cout << Z;
}


Measured memory_bytes: 256
from collections import deque
Sa = deque(list(input()))
Sb = deque(list(input()))
Sc = deque(list(input()))
s = Sa.popleft()
while True:
    if s == 'a':
        if not Sa:
            flag = 'a'
            break
        s = Sa.popleft()
    elif s == 'b':
        if not Sb:
            flag = 'b'
            break
        s = Sb.popleft()
    else:
        if not Sc:
            flag = 'c'
            break
        s = Sc.popleft()
if flag == 'a':
    print('A')
elif flag == 'b':
    print('B')
else:
    print('C')

Measured memory_bytes: 3316
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
#define VL vector<ll>
#define VS vector<string>
#define VB vector<bool>
#define VP vector<pair<ll,ll>>
#define VVL vector<vector<ll>>
#define VVP vector<vector<pair<ll,ll>>>
#define PL pair<ll,ll>
#define ALL(v) (v).begin(), (v).end()
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;

int main(){
    ll a,b,c,d,e;
    cin >> a >> b >>c >>d >>e;
    if(a==0)cout<<1<<endl;
    else if(b==0)cout<<2<<endl;
    else if(c==0)cout<<3<<endl;
    else if(d==0)cout<<4<<endl;
    else if(e==0)cout<<5<<endl;
}

Measured memory_bytes: 3616
#include <stdio.h>

int main(void) {
	int n,p,x1,y1,z1,w1,x2,y2,z2,w2;
	int t,i,j,k;
	while(scanf("%d",&n),n != 0){
		for(p = 1;p <= n;p++){
			scanf("%d%d%d%d%d%d%d%d",&x1,&y1,&z1,&w1,&x2,&y2,&z2,&w2);
			t = x1*x2-y1*y2-z1*z2-w1*w2;
			i = y1*x2+x1*y2-w1*z2+z1*w2;
			j = z1*x2+w1*y2+x1*z2-y1*w2;
			k = w1*x2-z1*y2+y1*z2+x1*w2;
			printf("%d %d %d %d\n",t,i,j,k);
		}
	}
	return 0;
}

Measured memory_bytes: 600
S = list(map(str,input()))
# s = "><<<<><<"
# S = list(map(str,s))
num = [-1]*(len(S)+1)
index0 = list()
than = 0# 0 == >, 1 == <
#----------------------------------------
for i in range(len(S)):
    if(S[i] == '<'):
        if(than == 0):
            num[i] = 0
            index0.append(i)
        than = 1
    else:
        than = 0
if(S[-1] == '>'):
    num[-1] = 0
    index0.append(len(S)+1)
#--------------------------------------
if(index0[0] == 0):
    i = 1
    while(True):
        num[i] = num[i-1]+1
        if(i >= len(S)):break
        if(S[i] == '>'):
            break
        i+=1
    index0.pop(0)
if(len(index0)>0):
    if(index0[-1] == len(S)+1):
        i = len(S)-1
        while(True):
            num[i] = num[i+1]+1
            i-=1
            if(i < 0):break
            if(S[i] == '<'):break
        index0.pop(-1)

while(len(index0)>0):
        for i in reversed(range(0,index0[0])):
            if(S[i] == '<'):
                break
            num[i] = max(num[i],num[i+1]+1)
        for i in range(index0[0]+1,len(S)+1):
            num[i] = max(num[i],num[i-1]+1)
            if(i >= len(S)):break
            if(S[i]== '>'):break
        index0.pop(0)

ans = 0
for i in range(len(num)):
    ans += num[i]
print(ans)


Measured memory_bytes: 33368
#include <bits/stdc++.h>
using namespace std;

signed main () {
	int n;
	cin >> n;
	unordered_set < int > xyu;
	for (int i = 0; i < n; ++i) {
		int x;
		cin >> x;
		xyu.insert(x);
	}
	if (xyu.size() == n)
		cout << "YES\n";
	else
		cout << "NO\n";
}


Measured memory_bytes: 8520
package main

import "fmt"

func main() {
	var n, a, cnt int
	fmt.Scan(&n)
	for i := 1; i <= n; i++ {
		fmt.Scan(&a)
		if i%2 == 1 {
			if a%2 == 1 {
				cnt++
			}
		}
	}
	fmt.Println(cnt)
}


Measured memory_bytes: 1772
#include <bits/stdc++.h>
#define rep(i, to) for (int i = 0; i < (to); ++i)
#define repf(i, from, to) for (int i = (from); i < (to); ++i)
#define unless(cond) if (!(cond))
using namespace std;
using ll = long long;
template <typename T>
using V = vector<T>;
template <typename T, typename U>
using P = pair<T, U>;

int main() {
  int n, a, b;

  cin >> n >> a >> b;

  string ans;
  int between_num = (b - 1) - a;

  if(between_num % 2 == 1) {
    ans = "Alice";
  } else {
    ans = "Borys";
  }

  cout << ans << endl;
}


Measured memory_bytes: 3628
n,m,x=map(int,input().split())
a=list(map(int,input().split()))
low=[]
high=[]
for i in range(len(a)):
    if a[i]<x:
        low.append(a[i])
    else:
        high.append(a[i])
print(min(len(high),len(low)))

Measured memory_bytes: 3060
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
int main(int argc, char* argv[]) {
   string s;
   cin >> s;
   int count = 0;
   int max = 0;
    for (int i = 0; i < s.size() ; i++) {
       if((s[i]=='G')||(s[i]=='A')||(s[i]=='T')||(s[i]=='C')){
           count ++;
           if(max<=count) max = count;
       }
       else {
           if(max<=count) max = count;
           count = 0;
    }
    
    

    }
    cout << max; 
    return 0;    }


Measured memory_bytes: 256
#include<stdio.h>
int main(void){
	int a,b,c,d,count = 0;
	scanf("%d %d %d",&a,&b,&c);
        while(1){
                d = c % a;
		if(d == 0) count++;
                a++;
                if(a>b) break;
       }
	printf("%d\n",count);
	return 0;
}
	

Measured memory_bytes: 596
import java.util.Scanner;
public class Main {
	public static void main(String[]  args) {
		Scanner input = new Scanner(System.in);		
          String x = input.nextLine();
		  String Splitt[] = x.split(" ");
		  for(String word: Splitt){
		     System.out.print(word.charAt(0)); }
		   }
			
		}
	
	




Measured memory_bytes: 26908
#include <stdio.h>

main(){

  int i = 0, j = 0, k = 0;
  int A[101];
  int N = 1;
  int key = 0;
  
  scanf("%d",&N);
  
  for (k=1;k<=N;k++){
    scanf("%d",&A[k]);
  }
    
  for (j=1;j<=N;j++){
    key = A[j];
    i = j - 1;
    while ((i>0) && (A[i]>key)){
      A[i+1] = A[i];
      i = i - 1;
    }
    A[i+1] = key;
    for (k=1;k<=N;k++){
      printf("%d",A[k]);
      if(k<N){
	printf(" ");
      }
    }
    printf("\n");
  }

}

Measured memory_bytes: 0
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <map>
#include <string>
#include <cstdio>
#include <cstring>
#include <climits>
#include <vector>
//#include <tuple>
using namespace std;
#define rep(i,n) for(LL i=0;i<n;i++)
#define all(v)	(v).begin(),(v).end()
#define MOD  1000000007
const int INF = INT_MAX;
typedef long long LL;
typedef pair<int, int> pii;
//typedef tuple<int, int> tii;

int main(){
	int w[10] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 };
	int n;
	while (cin >> n){
		vector<int> v;
		for (int i = 9; i >= 0; i--){
			if (n >= w[i]){
				v.push_back(w[i]);
				n -= w[i];
			}
		}
		sort(all(v));
		rep(i, v.size()-1){
			cout << v[i] <<" ";
		}
		cout << v[v.size() - 1] << endl;
	}
	return 0;
}

Measured memory_bytes: 1216
x1,y1,x2,y2=input().split()
x1,y1,x2,y2=int(x1),int(y1),int(x2),int(y2)
x3=x2+y1-y2
y3=y2+x2-x1
x4=x1+y1-y2
y4=y1+x2-x1
print(" ".join([str(x3),str(y3),str(x4),str(y4)]))


Measured memory_bytes: 3060
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AtCoder
{
    class Program
    {
        static void Main()
        {
            Solve();

            Console.ReadKey();
        }

        static void Solve()
        {
            var N = IO.GetInt();
            var A = IO.GetIntList();
            var ans = 1 / A.Select(a => 1 / (double)a).Sum();

            Console.WriteLine(ans);
        }
    }


    static class IO
    {
        static public string GetString() { return Console.ReadLine(); }
        static public int GetInt() { return int.Parse(Console.ReadLine()); }
        static public long GetLong() { return long.Parse(Console.ReadLine()); }
        static public List<string> GetStringList() { return Console.ReadLine().Split(' ').ToList(); }
        static public List<int> GetIntList() { return Console.ReadLine().Split(' ').Select(int.Parse).ToList(); }
        static public List<long> GetLongList() { return Console.ReadLine().Split(' ').Select(long.Parse).ToList(); }
        static public List<double> GetDoubleList() { return Console.ReadLine().Split(' ').Select(double.Parse).ToList(); }
        static public void WriteStrings<T>(IEnumerable<T> values) { foreach (var o in values) { Console.Write(o + " "); } }
    }
}

Measured memory_bytes: 13396
#include <stdio.h>


int main(void) {

	// 1_1-D watch
	int h,m,s;
	scanf("%d",&s);
	
	// ????????????
	m = s / 60;
	s = s % 60;

	// ???????????????
	h = m / 60;
	m = m % 60;

	printf("%d:%d:%d\n",h,m,s);
        return 0;
}

Measured memory_bytes: 592
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
    int h, w;
    boolean[][] dat;
    static final int INF = Integer.MAX_VALUE >> 1;
    int sum;

    public static void main(String[] args) {
        Main m = new Main();
        m.read();
        m.solve();
    }

    private void read() {
        Scanner sc = new Scanner(System.in);
        h = sc.nextInt();
        w = sc.nextInt();
        dat = new boolean[h][w];
        sum = 0;
        sc.nextLine();
        for (int i = 0; i < h; i++) {
            char[] line = sc.nextLine().toCharArray();
            for (int j = 0; j < w; j ++) {
                dat[i][j] = line[j] == '.';
                if (!dat[i][j])
                    sum++;
            }
        }
    }

    private void solve() {
        int[][] memo = new int[h][w];
        for (int i = 0; i < h; i++)
            Arrays.fill(memo[i], INF);
        PriorityQueue<Vertex> queue
                = new PriorityQueue<>(Comparator.comparing(Vertex::getCost));
        queue.add(new Vertex(0, 0, 1));
        memo[0][0] = 1;
        while (!queue.isEmpty()) {
            Vertex v = queue.poll();
            for (int dx = -1; dx <= 1; dx++) {
                for (int dy = -1; dy <= 1; dy++) {
                    if (dx != 0 && dy != 0)
                        continue;
                    int c = v.col + dx;
                    int r = v.row + dy;
                    if (0 <= c && c < h && 0 <= r && r < w
                            && dat[c][r] && memo[c][r] == INF) {
                        queue.add(new Vertex(c, r, v.cost+1));
                        memo[c][r] = v.cost + 1;
                    }
                }
            }
        }
        if (memo[h-1][w-1] == INF) {
            System.out.println(-1);
        } else {
            System.out.println((h * w) - sum - memo[h-1][w-1]);
        }
    }

    private class Vertex {
        int col;
        int row;
        int cost;
        Vertex (int i, int j, int c) {
            col = i; row = j; cost = c;
        }

        public int getCost() {
            return cost;
        }
    }
}


Measured memory_bytes: 28372
# include <bits/stdc++.h>
# define maxn 300003
# define ll long long
# define clock (clock() * 1000.0 / CLOCKS_PER_SEC)
# define rc(s) return cout << s,0
# define _ ios_base::sync_with_stdio(false);cin.tie(0);
# define pb push_back
# define mp make_pair
# define int ll
using namespace std;

int32_t main(){_
    int n,k,t,a[100001];
    int ans = 0;
    cin >> n >> k;
    for(int i = 1;i<=n;i++)
        cin >> a[i];
    for(int i = 1;i<=n-1;i++)
    {
        if(a[i] + a[i + 1] <= k) continue;
        t = a[i] + a[i+1] - k;
        ans += t;
        a[i + 1] -= t;
        if(a[i + 1] < 0) a[i+1] = 0;
    }
    rc(ans);
}


Measured memory_bytes: 1024
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    H,W=MI()
    for i in range(H):
        S=input()
        for _ in range(2):
            print(S)
        

main()


Measured memory_bytes: 38544
N = int(input())
a = list(map(int, input().split()))
A = 0
B = 0
for i in range(N):
    m = max(a)
    x = a.index(m)
    if i % 2 == 0:
        A += m
    else:
        B += m
    a[x] = 0
print(A - B)


Measured memory_bytes: 2940
import qualified Data.Bits as Bits

main::IO()
main = do
  n <- read <$> getLine
  ss <- map ox2Bool <$> getLine
  putStrLn $ solve n ss
  
ox2Bool ::  Char ->  Bool
ox2Bool ox =  case ox of
  'o' -> True
  _ -> False

solve :: Int -> [Bool] -> [Char]
solve n ss = do
  check $ map (solve0 n (head ss) (tail ss)) (sequence [ [True,False],[True,False]])  

solve0 ::Int ->Bool -> [Bool] -> [Bool] ->Maybe [Bool]
solve0 n car ls ans = case ls of
  [] -> case (head ans == last ans) && (foldr Bits.xor True [car,(head ans),(ans !! 1),((reverse ans)!!1)]) of
    True -> Just $ reverse $ tail ans
    _ -> Nothing
  x -> solve0 (n-1) car (tail x) ((foldr Bits.xor False [(head x),(ans !! 1),(head ans)]):ans)
  
check :: [Maybe [Bool]] -> String
check ls = case ls of
  []-> "-1"
  _-> case head ls of
    Nothing -> check $ tail ls
    Just x -> map (\ b-> case b of True -> 'S'; False ->'W') x

Measured memory_bytes: 32124
import java.io.*;
import java.util.*;

public class Main {

	final static long MOD = 1000000007;
	public static String[] Ws = null;
	public static int wsIndx = 0;
	public static BufferedReader in = null;
	public static void main(String[] args) throws Exception {
		solution(args);
		if(in!=null){
			in.close();
		}
	}

	public static void solution(String[] args) throws Exception{

		int a =nextInt();
		int b =nextInt();

		System.out.println((a+b+1)/2);

	}
	public static String[] toStringArray(String s) {
		String[] tmp = new String[s.length()];
		char[] c = s.toCharArray();
		for (int i = 0; i < tmp.length; i++) {
			tmp[i] = String.valueOf(c[i]);
		}
		return tmp;
	}

	public static void check() throws Exception{
		if(in == null){
			in = new BufferedReader(new InputStreamReader(System.in));
		}
		if(Ws==null || Ws.length<=wsIndx){
			Ws = in.readLine().split(" ");
			wsIndx=0;
		}
	}
	public static int nextInt()throws Exception{
		check();
		return Integer.parseInt(Ws[wsIndx++]);
	}

	public static long nextLong()throws Exception{
		check();
		return Long.parseLong(Ws[wsIndx++]);
	}

	public static String nextString()throws Exception{
		check();
		return Ws[wsIndx++];
	}

	public static int[] nextInts()throws Exception{
		check();
		int[] tmp = new int[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Integer.parseInt(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static long[] nextLongs()throws Exception{
		check();
		long[] tmp = new long[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Long.parseLong(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static String[] nextStrings()throws Exception{
		check();
		wsIndx=Ws.length;
		return Ws;
	}


}


Measured memory_bytes: 22484
#include <iostream>
#include <numeric>
#include <vector>
//#include<math.h>
#include <algorithm>
//#include <functional>
//#include <numeric>
//#include<cmath>
//#include <stdio.h> 
//#include <cstdint>
#include <string>
//#include <cstdlib>
//#define pi 3.14159265359
using namespace std;


	int main() {

		int n;
		cin >> n;
		string str;
		cin >> str;
		int si = (int)str.size();
		vector<int> nums(str.size());
		transform(str.begin(), str.end(), nums.begin(), [](char ch) { return ch - '0'; });
		const int* result = nums.data(); // int列の先頭 と
		const size_t size = nums.size(); // 列の長さ
		
		int num = 0;

		//cout << nums[2];
		
		//cout << nums[si - 1];

		for (int i = 0; i < 10; i++) {
			for (int x = 0; x < si-2; x++) {
				if (i == nums[x]) {
					//cout << i;
					for (int j = 0; j < 10; j++) {
						//cout << j;
						for (int y = x + 1; y < si-1; y++) {
							//cout << y;
							if (j == nums[y]) {
								//cout << j;
								for (int k = 0; k < 10; k++) {
									for (int z = y + 1; z < si; z++) {
										if (k == nums[z]) {
											//cout << k;
											num += 1;
											break;
										}
									}
								}
								break;
							}
						}
					}
					break;
				}
				
			}
		}

		cout << num;

		

		return 0;

	}


Measured memory_bytes: 384
n=int(input())
x=list(map(int,input().split()))
y=[x[i] for i in range(n)]
y.sort()
for i in range(n):
    if x[i]==y[n//2-1]:
        print(y[n//2])
    elif x[i]==y[n//2]:
        print(y[n//2-1])
    elif x[i] < y[n//2-1]:
        print(y[n//2])
    else:
        print(y[n//2-1])

Measured memory_bytes: 26772
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
ll MOD = 1e9 + 7;
int r[200000];
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int N, P;
	cin >> N >> P;
	string S;
	cin >> S;
	if (P == 2) {
		ll ans = 0;
		for (int i = 0; i < S.size(); i++) {
			if ((S[i] - '0') % 2 == 0) {
				ans += i + 1;
			}
		}
		cout << ans << endl;
		return 0;
	}
	if (P == 5) {
		ll ans = 0;
		for (int i = 0; i < S.size(); i++) {
			if (S[i]=='0' || S[i]=='5') {
				ans += i + 1;
			}
		}
		cout << ans << endl;
		return 0;
	}
	map<int, int> cnt;
	ll ans = 0;
	cnt[0]++;
	ll mul = 1;
	for (int i = S.size() - 1; i >= 0; i--) {
		r[i] = ((S[i] - '0')*mul) % P;
		if (i < S.size() - 1) (r[i] += r[i + 1]) %= P;
		ans += cnt[r[i]];
		cnt[r[i]]++;
		(mul *= 10) %= P;
	}
	cout << ans << endl;
}

Measured memory_bytes: 1684
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main(){
    ll h,w;
    cin >> h >> w;
    if(h%3==0 || w%3==0){
        cout << 0 << endl;
        return 0;
    }
    ll ans = min(h,w);
    for(ll i=1; i<=w-1; i++){
        ll s1,s2,s3;
        s1=i*h;
        if(h%2==0){
            s2=(w-i)*h/2;
            s3=(w-i)*h/2;
        }
        else{
            s2=(w-i)*(h/2);
            s3=(w-i)*(h/2+1);
        }
        ll dif = max(s1,s3) - min(s1,s2);
        ans = min(ans, dif);
    }
    for(ll i=1; i<=h-1; i++){
        ll s1,s2,s3;
        s1=i*w;
        if(w%2==0){
            s2=(h-i)*w/2;
            s3=(h-i)*w/2;
        }
        else{
            s2=(h-i)*(w/2);
            s3=(h-i)*(w/2+1);
        }
        ll dif = max(s1,s3) - min(s1,s2);
        ans = min(ans, dif);
    }
    cout << ans << endl;
}

Measured memory_bytes: 3636
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    int n ;
    std::vector< long > a ;
    std::cin >> n ;
    
    for( int i = 0 ; i < n ; i++ ) {
        long ii ;
        std::cin >> ii ;
        a.push_back( ii ) ;
    }
    std::cout << *std::min_element( a.begin() , a.end() ) << " " << *std::max_element( a.begin() , a.end() ) << " " << std::accumulate( a.begin() , a.end() , 0LL ) << std::endl ;
}




Measured memory_bytes: 3284
#include <bits/stdc++.h>
using namespace std;

int main()
{
	int nR, nC;
	int nInput[101][101] = { 0 };

	cin >> nR >> nC;

	int nRS = 0, nSum = 0;
	for (int i = 0; i < nR; i++)
	{
		nRS = 0;
		for (int j = 0; j < nC; j++)
		{
			cin >> nInput[i][j];
			nRS += nInput[i][j];
		}
		nInput[i][nC] = nRS;
		nSum += nRS;
	}
	nInput[nR][nC] = nSum;

	for (int i = 0; i < nC; i++)
	{
		nRS = 0;
		for (int j = 0; j < nR; j++)
		{
			nRS += nInput[j][i];
		}
		nInput[nR][i] = nRS;
	}

	for (int i = 0; i <= nR; i++)
	{
		for (int j = 0; j <= nC; ++j)
		{
			cout << nInput[i][j];
			if (nC!=j)
			{
				cout << " ";
			}
		}
		cout << endl;
	}
	return 0;
}

Measured memory_bytes: 3140
#include <bits/stdc++.h>
#define DUMP(x)  cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define IFOR(i, m, n) for(int i = n - 1; i >= m; i-- )
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
#define FOREACH(x,a) for(auto& (x) : (a) )
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
const ll INF = LLONG_MAX;
/* テンプレートここまで */

int main() {
  int N, L; cin >> N >> L;
  int sum = 0;
  FOR(i, 1, N+1){
    sum += L+i-1;
  }

  int ans = 0;
  int diff = 100000;
  FOR(i, 1, N+1){
    int tmp = 0;
    FOR(j, 1, N+1){
      tmp = sum -( L+i-1);
      if(abs(tmp-sum) < diff){
        diff  = abs(tmp-sum);
        ans = tmp;
      }
    }
  }
  cout << ans << endl;
}


Measured memory_bytes: 256
import java.util.Scanner;

class Main {
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		int b, r, g, c, s, t;
		int ans;
		
		while(true){
			b = scan.nextInt();
			r = scan.nextInt();
			g = scan.nextInt();
			c = scan.nextInt();
			s = scan.nextInt();
			t = scan.nextInt();
			
			if(b == 0 && r == 0 && g == 0 &&
			c == 0 && s == 0 && t == 0)break;
			
			ans = (100 + b*15*6 + r*15*4 + g*7 + c*2)
					-((t-s)*3 - (b*5 + r*3)) ;
			
			System.out.println(ans);
		}
	}
}

Measured memory_bytes: 28800
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

N = int(input())
print(N*180-360)


Measured memory_bytes: 4456
#include <stdio.h>
#include <iostream>

int main(){
    int a;
    int b;
    
    std::cin >> a >> b;
    if(a > b){
        printf("a > b");
    }else if(a < b){
        printf("a < b");
    }else{
        printf("a == b");
    }
    printf("\n");
}


Measured memory_bytes: 3208
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define FOR(i,a,b) for(ll i=(a);i<=(b);i++)
#define ALL(x) (x).begin(),(x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int main(){
  int N,M;
  cin >> N >> M;
  vector<int> l(M);
  vector<int> r(M);
  REP(i,M){
    cin >> l.at(i) >> r.at(i);
  }
  sort(ALL(l));
  sort(ALL(r));
  int d = r.at(0) - l.at(M-1);
  if (d<0) cout << 0 << endl;
  else cout << d + 1 << endl; 
}


Measured memory_bytes: 1024
n=int(input())
v=list(map(int,input().split()))
ans1=[0]*(10**5+1)#偶数
ans2=[0]*(10**5+1)#奇数
for i in v[0::2]:
  ans1[i]+=1
for i in v[1::2]:
  ans2[i]+=1
m1=max(ans1)
m2=max(ans2)
flag=False
for i in range(10**5+1):
  if ans1[i]==m1 and ans2[i]==m2:
    flag=True
    ans1.sort()
    ans2.sort()
    m12=ans1[-2]
    m22=ans2[-2]
    break
if len(set(v))==1:
  print(n//2)
elif flag==True:
  print(n-max(m12+m2,m1+m22))
else:
  print(n-m1-m2)

Measured memory_bytes: 17380
N = int(input())
A = [int(input()) for _ in range(N)]

def solve(A):
    ans = 0
    visited = [True] + [False]*(N-1)
    i = 0
    while i!=1:
        i = A[i]-1
        if visited[i]==True:
            break
        visited[i]=True
        ans += 1
    if i==1:
        return ans 
    return -1
print(solve(A))

Measured memory_bytes: 8620
#include<bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=(a),_ed=(b);i<=_ed;++i)
#define DREP(i,a,b) for(int i=(a),_ed=(b);i>=_ed;--i)
#define mp(x,y) make_pair((x),(y))
#define sz(x) (int)(x).size()
#define pb push_back
typedef long long ll;
typedef pair<int,int> pii;
inline int read(){
    register int x=0,f=1;register char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=0;ch=getchar();}
    while(isdigit(ch)){x=x*10+(ch^'0');ch=getchar();}
    return f?x:-x;
}

int n,m,x[100005],y[100005],vis[405][405],can[405];

int main(){
	// freopen("in.in","r",stdin);
	n=read(),m=read();
	REP(i,1,m)x[i]=read(),y[i]=read();
	REP(i,1,n){
		vis[i][i]=1,can[i]=1;
		DREP(j,m,1){
			if(vis[i][x[j]]&&vis[i][y[j]])can[i]=0;
			else if(vis[i][x[j]])vis[i][y[j]]=1;
			else if(vis[i][y[j]])vis[i][x[j]]=1;
		}
	}
	int ans=0;
	REP(i,1,n)if(can[i])REP(j,i+1,n)if(can[j]){
			++ans;
			REP(k,1,n)if(vis[i][k]&vis[j][k]){--ans;break;}
		}
	printf("%d\n",ans);
	return 0;
}


Measured memory_bytes: 1664
#include <bits/stdc++.h>

#define lli long long int
#define endl '\n'
#define loop(i, a, b) for (int i = a; i < b; i++)
#define vi vector<lli>
#define vpi vector<lli, lli>
#define all(v) v.begin(), v.end()
#define sz(a) a.length()
// #define sz(a) a.size()
#define gif(a, b) ((a) % (b) == 0 ? (a) / (b) : (a) / (b) + 1)
#define it(b) for (__typeof(b.begin()) it = b.begin(); it != b.end(); it++)

using namespace std;

lli pow(lli a,lli b){
    if(b==0) return 1;
    return a*pow(a,b-1);
}

int shuruHoJaa(int test)
{
    while (test--)
    {
        int d,t,s;
        cin>>d>>t>>s;
        if(d<=t*s){
            cout<<"Yes";
        }
        else
        {
            cout<<"No";
        }
        
        
    }

    return 0;
}

int main()
{
    int t;
    t=1;
    shuruHoJaa(t);
    return 0;
}

Measured memory_bytes: 3628
class Node:
    def __init__(self, value, parent):
        self.val = value
        self.left = None
        self.right = None
        self.parent = parent

class BinarySearchTree:
    def __init__(self):
        self.root = None
    
    def insert(self,key):
        node = Node(key, None)
        if self.root == None:
            self.root = node
        else:
            curr_node = self.root
            while curr_node:
                parent_node = curr_node
                if key < curr_node.val:
                    curr_node = curr_node.left
                else:
                    curr_node = curr_node.right
            node.parent = parent_node
            if key < parent_node.val:
                parent_node.left = node
            else:
                parent_node.right = node
     
    def find(self, key):
        if self.root == None:
            return False
        else:
            curr_node = self.root
            while curr_node:
                if key == curr_node.val:
                    return True
                elif key < curr_node.val:
                    curr_node = curr_node.left
                else:
                    curr_node = curr_node.right
            return False
            
        
        
        
    def preorderTraversal(self, node):
        result = []
        if node == None:
            return result
        result += [node.val]
        result += self.preorderTraversal(node.left)
        result += self.preorderTraversal(node.right)
        return result
        
    def inorderTraversal(self, node):
        result = []
        if node == None:
            return result
        result += self.inorderTraversal(node.left)
        result += [node.val]
        result += self.inorderTraversal(node.right)
        return result

N = int(input())
command = []
for i in range(N):
    command.append(tuple(input().split()))

T = BinarySearchTree()
for com in command:
    if com[0] == 'insert':
        T.insert(int(com[1]))
    if com[0] == 'find':
        flag = T.find(int(com[1]))
        if flag:
            print('yes')
        else:
            print('no')
    if com[0] == 'print':
        In = T.inorderTraversal(T.root)
        Pre = T.preorderTraversal(T.root)
        print(' ' + ' '.join(list(map(str, In))))
        print(' ' + ' '.join(list(map(str, Pre))))



Measured memory_bytes: 214256
#include<iostream>
#include<cstdlib>
#include<utility>
#include<tuple>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>
#include<queue>
#include<deque>
#include<bitset>
#include<cmath>
#include<map>
#include<iomanip>
using namespace std;
using ll = long long int;
const ll mod = 1e9 + 7;
#define rep(i, a, b) for(ll i = a; i <= b; i++)

int main() {

	ll n;
	cin >> n;

	ll m = n, j, k = 1e12, l = 0, dn = sqrt(n);

	rep(i, 1, dn) {
		if (n % i == 0) {
			j = i;
			m = n / i;
			if (j + m < k + l) {
				k = j;
				l = m;
			}
		}
	}

	cout << k + l - 2 << endl;

	return 0;
}

Measured memory_bytes: 384
#include <iostream>
#include <vector>
#include <string>
#define FOR(i,M) for(int i = 0;i<M;i++)
using namespace std;


long long sum = 0;


void sprit(string s, int n,string& lS,string& rS)
{
	lS = s.substr(0, n), rS = s.substr(n);
}

void add(string s)
{
	long long i = 0, sub = 0;
//	cout <<"str : "<< s << endl;
	while (i < s.size())
	{
		sub = 0;
		while (s[i] != '+' && i < s.size())
		{
			sub = sub * 10 + s[i] - '0';
			i++;
			
		}
		sum += sub;
//		cout <<"sub : " << sub << endl;
		i++;
	}
}

void set(string  S, vector<int> &a)
{
	FOR(i, S.length())
	{
		a[i] = S[i] - '0';
	}
}

void dfs(string s,int n)//n番目とn+1番目の間まで+を入れない
{
	if (n >= s.size())
	{
		return;
	}
//	cout << "n : " << n << endl;
	string S = s;
	s.insert(n, "+");
	add(s);
//	add(S);
	dfs(s, n + 2);
	dfs(S, n + 1);
}


void solve(string s,int n) 
{


}

int main()
{
	string S;
	cin >> S;
//	set(S, a);
	
	dfs(S, 1);
	sum += stoll(S);
	cout << sum;
}


Measured memory_bytes: 256
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
/* 動的計画法
int main(){
    int n;
    int dp[100];
    dp[0]=1;
    dp[1]=1;
    cin >> n;
    for(int i=2;i<=n;i++){
        dp[i]=dp[i-1]+dp[i-2];
        //printf("dp[%d]=%d\n",i,dp[i]);
    }
    

    cout<<dp[n]<<endl;
}
*/
//メモ化再帰
int dp[100];
int n;
int fib(int n){
    if(n==0||n==1)return 1;
    if(dp[n]!=-1)return dp[n];
    return dp[n]=fib(n-1)+fib(n-2);
}

int main(){
    for (int i = 0; i < sizeof(dp)/sizeof(dp[0]); i++)
    {
        dp[i] = -1;
    }
    dp[0]=dp[1]=1;
    cin >> n;
    cout<<fib(n)<<endl;
}


Measured memory_bytes: 3104
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <queue>
#include <climits>
typedef long long ll;
using namespace std;

int main(void){
  string s;
  int n,i;

  cin>>n>>s;

  for(i=0;i<s.size();i++){
    printf("%c",'A'+(s[i]-'A'+n)%26);
  }
  printf("\n");

  return 0;
}



Measured memory_bytes: 256
#### import ####
import sys
import math
from collections import defaultdict

#### 設定 ####
sys.setrecursionlimit(10**7)

#### 定数 ####
mod = 10**9 + 7

#### 読み込み ####
def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N):
  read_all = [tuple(map(int, input().split())) for _ in range(N)]
  return map(list,zip(*read_all))

#################

N = I()
s = []
for i in range(N):
  a = input()
  b = []
  for i in range(len(a)):
    b.append(ord(a[i]))
  b.sort()
  s.append(b)
s.sort()
ans = 0
temp = 1
for i in range(1,N):
  if s[i]==s[i-1]:
    temp += 1
  else:
    ans += temp*(temp-1)//2
    temp = 1
ans += temp*(temp-1)//2
print(ans)

Measured memory_bytes: 73944