Go: package main

import (
	"fmt"
	"sort"
)

func main() {
	var max int

	numbers := map[int]int{}
	for {
		var a int
		_, err := fmt.Scan(&a)
		if err != nil {
			break
		}
		numbers[a]++
		if numbers[a] >= max {
			max = numbers[a]
		}
	}

	var modes []int
	for a, b := range numbers {
		if b == max {
			modes = append(modes, a)
		}
	}

	sort.Ints(modes)
	for _, mode := range modes {
		fmt.Println(mode)
	}
}

C++: #include <iostream>
#include <stdio.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>

using namespace std;

int main(){
	int a[101];
	for(int i = 0;i < 101;i++){
		a[i] = 0;
	}
	int n;
	while(cin >> n){

		for(int i = 0;i < 101;i++){
			if(i == n){
				a[i]++;
			}
		}
	}
	int hold = a[0];
	for(int i = 1;i < 101;i++){
		if(hold < a[i]){
			hold = a[i];
		}
	}
	for(int i = 0;i < 101;i++){
		if(a[i] == hold) cout << i << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <iterator>
#include <stack>
typedef long long int lli;
using namespace std;

/*
long long int dp[1001][2][2][2];
int main(){
	for(int i=0; i<1001; ++i){
		for(int j=0; j<2; ++j){
			for(int k=0; k<2; ++k){
				for(int l=0; l<2; ++l){
					dp[i][j][k][l]=0;
				}
			}
		}
	}
	int N;
	cin >> N;
	string str;
	cin >> str;
	if(str[0]=='J'){
		for(int i=0;i<2; ++i){
			for(int j=0; j<2; ++j){
				dp[1][1][i][j]=1;
			}
		}
	} else if(str[0]=='O'){
		for(int i=0; i<2; ++i){
			dp[1][1][1][i]=1;
		}
	} else if(str[0]=='I'){
		for(int i=0; i<2; ++i){
			dp[1][1][i][1]=1;
		}
	}

	for(int i=2; i<=N; ++i){
		if(str[i-1]=='J'){
			dp[i][1][0][0]+=(dp[i-1][1][0][0]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][1][0]+=(dp[i-1][1][0][0]+dp[i-1][0][1][0]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][0][1]+=(dp[i-1][1][0][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][1][1]+=(dp[i-1][1][0][0]+dp[i-1][0][1][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
		} else if(str[i-1]=='O'){
			dp[i][0][1][0]+=(dp[i-1][0][1][0]+dp[i-1][1][1][0]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][1][0]+=(dp[i-1][1][0][0]+dp[i-1][0][1][0]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][0][1][1]+=(dp[i-1][0][1][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][1][1]+=(dp[i-1][1][0][0]+dp[i-1][0][1][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
		} else if(str[i-1]=='I'){
			dp[i][0][0][1]+=(dp[i-1][0][0][1]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][0][1]+=(dp[i-1][1][0][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][0][1][1]+=(dp[i-1][0][1][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
			dp[i][1][1][1]+=(dp[i-1][1][0][0]+dp[i-1][0][1][0]+dp[i-1][0][0][1]+dp[i-1][1][1][0]+dp[i-1][1][0][1]+dp[i-1][0][1][1]+dp[i-1][1][1][1])%10007;
		}
	}
	long long int ans=0;
	for(int i=0; i<2; ++i){
		for(int j=0; j<2; ++j){
			for(int k=0; k<2; ++k){
				ans+=dp[N][i][j][k]%10007;
			}
		}
	}
	cout << ans%10007 << "\n";
	return 0;
}
/*
int main(){
	int N,M;
	cin >> N >> M;
	vector<int> cost(N);
	vector<int> border(M);
	vector<int> pnt(N);
	for(int i=0; i<N; ++i){
		cin >> cost[i];
	}
	for(int i=0; i<M; ++i){
		cin >> border[i];
	}
	for(int i=0; i<M; ++i){
		for(int j=0; j<N; ++j){
			if(border[i]>=cost[j]){
				++pnt[j];
				break;
			}
		}
	}
	int max_p=-1;
	int ans;
	for(int i=0; i<N; ++i){
		if(pnt[i]>max_p) {
			max_p=pnt[i];
			ans=i+1;
		}
	}
	cout << ans << "\n";
	return 0;
}*/
/*
int main(){
	int hoge[5];
	int sum=0;
	for(int i=0; i<5; ++i){
		cin >> hoge[i];
		if(hoge[i]<40) hoge[i]=40;
		sum+=hoge[i];
	}
	cout << sum/5 << "\n";
	return 0;
}*/

/*
int abs(int x){
	if(x<0) return x*-1;
	else return x;
}

int main(){
	int W,H,N,ans=0;
	cin >> W >> H >> N;
	vector<pair<int,int> > xy(N);
	for(int i=0; i<N; ++i){
		cin >> xy[i].first >> xy[i].second;
	}
	int sx=xy[0].first;
	int sy=xy[0].second;
	for(int i=1; i<N; ++i){
		int gx=xy[i].first;
		int gy=xy[i].second;
		if((sx<=gx&&sy<=gy)||(gx<=sx&&gy<=sy)){
			if(abs(sx-gx)<abs(sy-gy)){
				ans+=abs(sy-gy);
			} else {
				ans+=abs(sx-gx);
			}
		} else {
			ans+=abs(sx-gx)+abs(sy-gy);
		}
		sx=gx;
		sy=gy;
	}
	cout << ans << "\n";
	return 0;
}*/

int main(){
	int n;
	vector<int> tmp(100+1);
	while(cin>>n&&n){
		++tmp[n];
	}
	int MAX=0;
	for(int i=1; i<=100; ++i){
		if(MAX<tmp[i]) MAX=tmp[i];
	}
	for(int i=1; i<=100; ++i){
		if(MAX==tmp[i]) cout << i << "\n";
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <deque>
using namespace std;
int main(){
	int data[150]={0},cp[150]={0},t,cnt=1,max,i=0;
	while(cin>>t){
		data[t]++;
		cnt++;
	}
	for(i=0;i<cnt;i++){
		cp[i]=data[i];
	}
	sort(data,data+150);
	for(int j=0;j<cnt;j++){
		if(data[0]==cp[j]){
			cout<<i<<endl;
		}
	}
return 0;
}

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

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)

using namespace std;

int c[101];

int main(){
	ios::sync_with_stdio(false);
	int n;
	while (cin>>n){
		c[n]++;
	}
	int ma=0;
	REP(i,101){
		ma=max(ma,c[i]);
	}
	REP(i,101){
		if (c[i]==ma){
			cout<<i<<endl;
		}
	}
	return 0;
}

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

int main()
{
	int count = 0;
	int _in;
	int in[101] = {};
	
	while(scanf("%d",&_in)+1){
		++in[_in];	
	}
	
	_in = max(in[0],in[101]);
	
	for(int i=0;i<101;++i){
		if(in[i] == _in){
			cout << i << endl;
		}
	}
	
	return 0;
}

C++: // Mode value

#include <iostream>
#include <algorithm>
#include <vector>

using std::cout;		using std::endl;
using std::cin;			using std::sort;
using std::vector;

int main(void)
{
	int num;
  int counters[101] = {0};
	int max_count = 1;
	vector<int> numbers;

  while (cin >> num) {
    counters[num]++;
  }

  for (int i = 1; i <= 100; i++) {
    if (max_count < counters[i]) {
      if (numbers.empty()) {
        numbers.push_back(i);
      } else {
        numbers.erase(numbers.begin(), numbers.end());
        numbers.push_back(i);
      }
      max_count = counters[i];
    } else if (max_count == counters[i]) {
      numbers.push_back(i);
    }
  }

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

  for (vector<int>::const_iterator iter = numbers.begin(); iter != numbers.end(); iter++) {
    cout << *iter << endl;
  }

  return 0;
}

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

int num[10];
int big = 0;
int input;
int main(){
	for(int i=0; i < 10; i++) num[i]=0;
	while(cin >> input) num[input]++;
	for(int i=0; i < 10; i++) big = max(big, num[i]);
	for(int i=0; i < 10; i++) if(num[i] == big) cout << i << endl;
}

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

int main(){
	int n[101], k, max=0;
	string ans;

	for (int i = 0; i < 101; i++) {
		n[i] = 0;
	}

	while(true){
		cin >> k;
		if (cin.eof()) { break; }
		n[k]++;
	}
	for(int i = 0;i<101;i++){
		if(max == n[i]){
			ans += "\n";
			ans += to_string(i);
		}
		else if (max < n[i]){
			ans = to_string(i);
			max = n[i];
		}
	}
	cout << ans << endl;
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

#define REP(i, s, n) for (int i = s; i < n; ++i)
#define rep(i, n) REP(i, 0, n)
#define SORT(c) sort((c).begin(), (c).end())
#define IINF INT_MAX
#define LLINF LLONG_MAX
#define DEBUG false

//Zeller's conguence

int main()
{
    int a[101]={0};
    int n;
    while(cin>>n){
        a[n]++;
    }
    //cout<<"hoge"<<endl;
    int temp=0;
    rep(i,101) temp=max(temp,a[i]);
    vector<int> hoge;
    rep(i,101) if(temp==a[i]) hoge.push_back(i);
    SORT(hoge);
    rep(i,hoge.size()){
        cout<<hoge[i]<<endl;
    }
    return 0;
}