n = int(input())
A = sorted(int(i) for i in input().split())

i = n-3
while i >= 0 and (A[i] + A[i+1] <= A[i+2]) :
    i -= 1

if i >= 0 :
    print(A[i],A[i+1],A[i+2])
else :
    print(-1)

import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] a = new int[n];
        for(int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }
        scanner.close();
        Arrays.sort(a);
        int x, y, z;
        for(x=n-3, y=n-2, z=n-1; a[x]+a[y]<=a[z]; x--, y--, z--){
            if(x==0) {
                System.out.print(-1);
                return;
            }
        }
        System.out.printf("%d %d %d", a[x], a[y], a[z]);
    }
}

import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;

public class Solution {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        Integer [] stick = new Integer[N];
        for (int i = 0; i < N; i++) {
            stick[i] = scan.nextInt();
        }
        scan.close();        
        findTriangle(stick);
    }
    
    /* Greedy Approach: Try to use the biggest sticks first */
    private static void findTriangle(Integer [] stick) {
        Arrays.sort(stick, Collections.reverseOrder());
        for (int i = 0; i < stick.length - 2; i++) {
            if (stick[i] < stick[i+1] + stick[i+2]) {
                System.out.println(stick[i+2] + " " + stick[i+1] + " " + stick[i]);
                return;
            }
        }
        System.out.println(-1);
    }
}

bool isvalid(int a, int b, int c){
    return a+b>c;
}

int n;
cin>>n;
vector<int> v(n);
for(int i = 0; i<n; ++i){
    cin>>v[i];
}
sort(v.begin(), v.end(), /* descending */);

for(int i = 2; i<n; ++i){
    if(isvalid(v[i], v[i-1], v[i-2])){
        cout<<v[i]<<" "<<v[i-1]<<" "<<v[i-2]<<endl;
        return 0;
    }
}
cout<<-1<<endl;
return 0;

static int[] maximumPerimeterTriangle(int[] s) {
  // Triangle inequality theorem states that
  // for any non-degenerate triangle, the sum 
  // of the lengths of any two sides must be 
  // greater than the length of the remaining 
  // side.

  // Sort sticks in ascending order.
  Arrays.sort(s);
  // Reverse sticks in decending order.
  for(int left = 0 ; left < s.length / 2; left++) { 
    int right = s.length - 1 - left;
    int tmp = s[left]; 
    s[left] = s[right]; 
    s[right] = tmp;
  }
  // Go through the sticks in
  // descending order.
  for(int i = 0 ; i < s.length - 2 ; ++i) {
    if (s[i] < s[i+1] + s[i+2]) {
      // This is a non-degenerate triangle.
      // Because we ordered the sticks
      // in descending order this
      // triangle must have the maximum
      // perimeter.
      return new int[] { s[i+2], s[i+1], s[i] };        
    }
  }
  return new int[] { -1 }; 
}