Go: package main

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

var rdr = bufio.NewReaderSize(os.Stdin, 1000000)

func readLine() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func toInt(str string) int {
	n, _ := strconv.Atoi(str)
	return n
}

func main() {
	lst := make([]int, 0)
	for i := 0; i < 10; i++ {
		lst = append(lst, toInt(readLine()))
	}
	sort.Ints(lst)
	for i := 9; i > 6; i-- {
		fmt.Println(lst[i])
	}
}

C++: #include <iostream>

int main(int argc, const char *argv[]) {
    int top1 = 0, top2 = 0, top3 = 0;
    for (int i = 0, h; i < 10 && std::cin >> h; i++) {
        if (h >= top1) {
            top3 = top2;
            top2 = top1;
            top1 = h;
        } else if (h >= top2) {
            top3 = top2;
            top2 = h;
        } else if (h >= top3) {
            top3 = h;
        }
    }
    std::cout << top1 << std::endl << top2 << std::endl << top3 << std::endl;
    return 0;
}

C++: #include<iostream>
#include<vector>
#include<algorithm>
#include <functional>
using namespace std;
int main()
{
	vector<int> m;
	int n;
	for (int i = 0; i < 10; i++)
	{
		cin >> n;
		m.push_back(n);
	}
	sort(m.begin(), m.end(), std::greater<int>());
	for (int i = 0; i < 3; i++)
		cout << m[i] << endl;
	return 0;
}

C++: #include <stdio.h>

int main(void)
{
	int i,high[3]={0,0,0},temp=0;
	for (i=0;i<10;i++){
		scanf("%d",&temp);
		if (high[2]<temp){
			high[2]=high[1];
			if (high[1]<temp){
				high[1]=high[0];
				if (high[0]<temp){
					high[0]=temp;
				}else{
					high[1]=temp;
				}
			}else{
				high[2]=temp;
			}
		}
	}
	
	for (i=0;i<3;i++){
		printf("%d\n",high[i]);
	}
	return 0;
}

C++: #include<stdio.h>
int mian(void)
{
	int i,j,n[11],w;
	for(i=0;i<10;i++){
		scanf("%d",n[i]);
	}
	for(i=0;i<10;i++){
		for(j=0;j<=10;j++){
			if(n[j]<=n[i]){
				w=n[i];
				n[i]=n[j];
				n[j]=w;
			}
		}
	}
	for(i=0;i<3;i++){
		printf("%d\n",y[i]);
	}
	return 0;
}

C++: ///==========================================================================
///
///                   Bismillah ir-Rahman ir-Rahim
///
/// ==========================================================================
///
///                    JU_UNDEFINED_CODERS
///
///                    Dept. of Computer Science and Engineering
///                    Jahangirnagar University , Bangladesh
///
/// ==========================================================================

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

#include<algorithm>
#include<cstdio>
#include<sstream>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<set>
#include<queue>
#include<stack>
#include<list>
#include<iostream>
#include<fstream>
#include<numeric>
#include<string>
#include<vector>
#include<cstring>
#include<map>
#include<iterator>
#include<deque>
#include<climits>
#include<complex>

using namespace std;

#define LL long long
#define ULL unsigned long long

// I/O
#define I(X)                       scanf("%d", &(X))
#define II(X, Y)                   scanf("%d%d", &(X), &(Y))
#define III(X, Y, Z)               scanf("%d%d%d", &(X), &(Y), &(Z))
#define DI(X) int (X);             scanf("%d", &X)
#define DII(X, Y) int X, Y;        scanf("%d%d", &X, &Y)
#define DIII(X, Y, Z) int X, Y, Z; scanf("%d%d%d", &X, &Y, &Z)

#define ILL(X) scanf("%lld", &(X))
#define DILL(X) LL (X); scanf("%lld", &X)

// LOOP
#define repv(i,a) for(int i=0;i<(int)a.size();i++)
#define revv(i,a) for(int i=((int)a.size())-1;i>=0;i--)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define rev(i,a,b) for(int i=a;i>=b;i--)

#define FS(x) for(typeof (x.begin()) it = x.begin(); it != x.end (); it++)
#define PR(x) for(typeof (x.begin()) it = x.begin(); it != x.end (); it++) {  cout << *it << " "; } cout << endl;

// array initialization
#define MEM(a,val) memset(a,val,sizeof(a));
#define SET(a) memset(a,-1,sizeof a)
#define CLR(a) memset(a,0,sizeof a)

// min-max
#define Max(a,b) (a>b?a:b)
#define _Max(a,b,c) Max(a,Max(b,c))
#define Min(a,b) (a<b?a:b)
#define _Min(a,b,c) Min(a,Min(b,c))
#define MAX(a) (*max_element(all(a)))
#define MIN(a) (*min_element(all(a)))

#define SQR(n) (n*n)
#define eps (1e-9)
#define PI (2.0*acos(0.0)) //#define PI acos(-1.0)

#define all(a) a.begin(),a.end()
#define pb push_back

#define NL printf("\n");
// pair
#define X first
#define Y second

// binary search
#define LB(a,x) (lower_bound(all(a),x)-a.begin())
#define UB(a,x) (upper_bound(all(a),x)-a.begin())

// segment tree
#define LEFT (idx<<1)
#define RIGHT (LEFT+1)

// IO
#define READ  freopen("C:\\Users\\back_bencher\\Desktop\\input.txt","r",stdin)
#define WRITE freopen("C:\\Users\\back_bencher\\Desktop\\output.txt","w",stdout)
#define _cin  ios_base::sync_with_stdio(0); cin.tie(0);

// BIT operation
#define countbit(x) __builtin_popcount(x)
template< class T, class X > inline bool   getbit(T a, X i) { T t=1; return ((a&(t<<i))>0); }
template< class T, class X > inline T      setbit(T a, X i) { T t=1;return (a|(t<<i)); }
template< class T, class X > inline T    resetbit(T a, X i) { T t=1;return (a&(~(t<<i))); }
template< class T, class X > inline T   togglebit(T a, X i) { T t=1;return (a^(t<<i)); }

// mathematics
template<typename T> T POW(T B,T P){ if(P==0) return 1; if(P&1) return B*POW(B,P-1);  else return SQR(POW(B,P/2));}
template<typename T> T BIGMOD(T b,T p,T m){ if(p==0) return 1; else if (!(p&1)) return SQR(Bigmod(b,p/2,m)) % m;else return ((b % m) * Bigmod(b,p-1,m)) % m;}
template<typename T> T Bigmod(T base,T power,T mod) { T ret=1; while(power)  { if(power & 1) ret=(ret*base)%mod; base=(base*base)%mod;  power>>=1; }return ret; }
template<typename T> T ModInverse(T number,T mod) { return Bigmod(number,mod-2,mod); }
template<typename T> T GCD(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}
template<typename T> T LCM(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}
template<typename T> T EUCLIDE(T a,T b,T &x,T &y) {if(a<0){T d=euclide(-a,b,x,y);x=-x;return d;}   if(b<0){T d=euclide(a,-b,x,y);y=-y;return d;}   if(b==0){x=1;y=0;return a;}else{T d=euclide(b,a%b,x,y);T t=x;x=y;y=t-(a/b)*y;return d;}}

// geometry
double DEG(double x) { return (180.0*x)/(PI);}
double RAD(double x) { return (x*(double)PI)/(180.0);}
template<typename T> T DIS(T x1,T y1,T x2, T y2){return sqrt( (double)( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) ) );}
template<typename T> T ANGLE(T x1,T y1,T x2, T y2){ return atan( double(y1-y2) / double(x1-x2));}
template<typename T> LL isLeft(T a,T b,T c) { return (c.x-a.x)*(b.y-a.y)-(b.x-a.x)*(c.y-a.y); }

// debug
void P_ARR(int *ar,int a,int b) {  if(a>b) swap(a,b); if(a<=b) cout << ar[a]; for(int i=a+1;i<=b;i++) cout << " "<<ar[i];  cout << endl; }

#define VI  vector< int >
#define VII vector< VI >
#define VLL vector< LL >
#define PII pair< int , int >
#define PLL pair< LL , LL >
#define VPI vector< PII >

int dir[9][2] = { {0,0} , {0,-1} , {1,0} , {0,1} , {-1,0} , {1,-1} , {1,1} , {-1,1} , {-1,-1}  };

/// ======================================================================================================
///              0123456789
const int   MX = 1000000;
const int  MOD = 1000000007;
const int  inf = 1000000000;

 int ar[1007];

int main()
{
    int tc,cas=1;

    rep(i,1,10) I(ar[i]);

    sort( ar+1,ar+1+10, greater<int>() );


    printf("%d\n",ar[1]);
    printf("%d\n",ar[2]);
    printf("%d\n",ar[3]);



    return 0;
}

C++: int main()
{
	int i,j;
	int rank1 = 0;
	int mountain[10] = {0};
	for (i = 0; i < 10; i++) {
		scanf("%d", &mountain[i]);
	}



	for (i = 0; i < 10; i++) {
		for (j = i + 1; j < 10; j++) {

			if (mountain[j] > mountain[i])
			{
				rank1 = mountain[i];
				mountain[i] = mountain[j];
				mountain[j] = rank1;
			}
		}
	}

	for (i = 0; i < 3; i++) {
		printf("%d\n", mountain[i]);

		}
	
	


    return 0;
}