Go: package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	heights := make([]int, 10)
	for i := 0; i < 10; i++ {
		sc.Scan()
		heights[i], _ = strconv.Atoi(sc.Text())
	}

	sort.Sort(sort.Reverse(sort.IntSlice(heights)))
	for i := 0; i < 3; i++ {
		fmt.Println(heights[i])
	}
}

C++: fn main(){
    let mut hs: Vec<i32> = vec![];
    for _i in 0..10{
        let n=readln();
        hs.push(n);
    }
    hs.sort();
    for i in (7..10).rev(){
        println!("{}",hs[i]);
    }
}
    

// --- template ---
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
 
pub trait FromLn {
    fn fromln(s: &str) -> Self;
}
pub fn readln<T: FromLn>() -> T {
    let mut buf = String::new();
    let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
    T::fromln(buf.trim())
}
pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
    let mut vs = vec![];
    for _ in 0..n {
        vs.push(readln());
    }
    vs
}
macro_rules! fromln_primitives {
    ($($t:ty),*) => { $(
        impl FromLn for $t {
            fn fromln(s: &str) -> $t {
                s.parse().unwrap()
            }
        }
    )* }
}
fromln_primitives!(
    String,
    bool,
    f32,
    f64,
    isize,
    i8,
    i16,
    i32,
    i64,
    usize,
    u8,
    u16,
    u32,
    u64
);
impl<T> FromLn for Vec<T>
where
    T: FromLn,
{
    fn fromln(s: &str) -> Vec<T> {
        s.split_whitespace().map(T::fromln).collect()
    }
}
impl FromLn for Vec<char> {
    fn fromln(s: &str) -> Vec<char> {
        s.chars().collect()
    }
}
macro_rules! fromln_tuple {
    ($($t:ident),*) => {
        impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
            fn fromln(s: &str) -> ($($t),*) {
                let mut it = s.split_whitespace();
                let t = ($($t::fromln(it.next().unwrap())),*);
                assert_eq!(it.next(), None);
                t
            }
        }
    }
}
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);

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

int main(){
  int h[10];

  for(int i=0;i<10;i++){
    cin >> h[i];
  }

  sort(h,h+10);

  for(int i=9;i>=7;i--)cout << h[i] << endl;

  return 0;
}

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

int main(){
    int hest[3];
    int h;
    for(int i=0;i<10;i++){
        std::cin>>h;
        for(int j=0;j<3;j++){
            if(hest[i]<h){
                hest[i] = h;
            }
        }
    }

    for(int j=0;j<3;j++){
        std::cout<<hest[i]<<std::endl;
    }

    return 0;
}

C++: #include <stdio.h>


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

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

int main(){
	
	int height[10] = {};

	for(int i = 0; i < 10; i++){
		cin >> height[i];
	}

	int f = 0, s = 0, t = 0;

	for (int i = 0; i < 9; i++){
		if (height[i] >= t){
			t = height[i];
		}
		if (t >= s){
			swap(s, t);
		}
		if (s >= f){
		swap(f,s);
		}
	}
    
	cout << f << "\n" << s << "\n" << t << endl;

		return 0;
}

C++: #include<iostream>
#include<algorithm>
using namespace std;
itn data[10];

int main(){
for(int i=0;i<10;i++)cin>>data[i];
sort(data,data+10);

for(int i=0;i<3;i++)cout<<data[i]<<endl;

}

C++: #include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <array>
#include <queue>
#include <deque>
#include <set>
#include <list>
#include <map>
#include <stack>
#include <utility>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <climits>
#include <bitset>
#include <random>
#include <functional>
#include <sstream>
#include <iomanip>

using namespace std;

#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for(int i=0; i<(n); i++)
#define FOR(i, m, n) for(int i=(m);i<(n);i++)
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define SORT(x) sort((x).begin(),(x).end())
#define REVE(x) reverse((x).begin(),(x).end())
#define mp make_pair
#define pb push_back

typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
typedef long long LL;

int main() {
	VI a(10);
	rep(i, 10)cin >> a[i];
	SORT(a); REVE(a);
	rep(i, 3)cout << a[i] << endl;
}

C++: #include <iostream>

using namespace std;

int main()
{
    int ma=0;
    int ma_2=0;
    int ma_3=0;
    int*A=new int[10];
    for(int c=0;c<10;c++)
    {
        cin>>A[c];
        if(ma<A[c])
        {
            ma_3=ma_2;
            ma_2=ma;
            ma=A[c];
        }
        else
        {
            if(ma_2<A[c])
            {
                ma_3=ma_2;
                ma_2=A[c];
            }
            else
            {
                if(ma_3<A[c])
                ma_3=A[c];
            }
        }
    }
    cout<<ma<<endl;
    cout<<ma_2<<endl;
    cout<<ma_3<<endl;
    return 0;
}

C++: #include <iostream>

int main(){
int a[10];
int max = 0;
int max2 = 0;
int max3 = 0;

for(int i = 0; i < 10; i++){
std::cin >> a[i];
}

for(int i = 0; i< 10; i++){
if(max < a[i]) max = a[i];
}

for(int i = 0; i< 10; i++){
if(max2 < a[i] && max != a[i]) max2 = a[i];
}

for(int i = 0; i< 10; i++){
if(max3 < a[i]&& max != a[i]&& max2 != a[i]) max3 = a[i];
}

std::cout << max<< std::endl;
std::cout << max2<< std::endl;
std::cout << max3<< std::endl;


return 0;
}

C++: //28
#include<iostream>
#include<algorithm>
#include<functional>

using namespace std;

int main(){
  int h[10];
  for(int i=0;i<10;i++){
    cin>>h[i];
  }
  sort(h,h+10,greater<int>());
  for(int i=0;i<3;i++){
    cout<<h[i]<<endl;
  }
  return 0;
}

C++: #include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <assert.h>
#include <complex>
#include <queue>
typedef long long ll;
#define REP(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(void){
    cin.tie(0);
    ios::sync_with_stdio(false);
    // ll も int も longlongにしてしまう
    #define int long long

    // intを要素に持つ優先順位付きキュー
    std::priority_queue<int> que;

    int height;
    while (cin >> height) {
        que.push(height);
    }
    
    for (int i = 0; i < 3; i++) {
        cout << que.top() << endl;
        que.pop();
    }

    return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <sstream>
#include <complex>
#include <ctime>
#include <cassert>

using namespace std;

typedef long long ll;
typedef vector<int> VI;
typedef pair<int,int> PII;

#define REP(i,s,t) for(int i=(s);i<(t);i++)
#define FILL(x,v) memset(x,v,sizeof(x))

const int INF = (int)1E9;
#define MAXN 100005


int main(){
	int h[10];
	REP(i,0,10) cin >> h[i];
	sort(h,h+10,greater<int>());
	REP(i,0,3) printf("%d\n", h[i]);
	return 0;
}

C++: #include <iostream>
#include <algorithm>

using namespace std;
int main(){
  int b[10];
  int a;
  for(int i=0; i < 10; i++){
    cin >> a;
    b[i] = a;
  }
  sort(b,b+10);
  for(int j=10; j > 7; j--){
    cout  << b[j-1]  << endl;
  }
}

C++: #include<stdio.h>
int main(void) {
	int i, mountain[10];
	int n = 0;
	int l = 0;
	int m = 0;
	for (i = 0;i < 10;i++) {
		scanf("%d", &mountain[i]);
	}
	for (i = 0;i < 10;i++) {
		if (mountain[i] > m) m = mountain[i];
	}
	printf("%d\n", m);
	for (i = 0;i < 10;i++) {
	if (mountain[i] > n && mountain[i] != m) n = mountain[i];
	}
	printf("%d\n", n);
	for (i = 0;i < 10; i++) {
		if (mountain[i] > l && mountain[i] != m && mountain[i] != n) l = mountain[i];
	}
	printf("%d\n", l);

	return 0;
}