#include <iostream>
#define ll long long
#include <vector>
using namespace std;
ll minSelectionsInWorstCase(vector<int>& choices) {
    ll n = choices.size();
    vector<int> s(n, 0); 
    ll t = 0;  
    s[n - 1] = choices[n - 1]; 
    for (int i = n - 2; i >= 0; --i) {
        s[i] = choices[i] + s[i + 1]; 
    }
    
    t = s[0]; 
    return t;
}

# include <bits/stdc++.h>
using namespace std;
#define ll long long
signed main(){
    
    string s; cin>>s;
    vector<ll>freq(26);
    for(auto it:s) freq[it-'a']++;
    bool f=0;
    for(ll i=0;i<26;i++)
    {
      if(freq[i]!=0) {cout<<char(i+'a'); f=1;}
      if(f) break;
    }
    if(!f) cout<<-1<<endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;
bool ss(int a, int b, int c, vector<int>& d, vector<pair<int, int>>& e, int f) {
    vector<int> g(a + 1, -1);
    queue<int> h;
    h.push(1); 
    g[1] = f; 
    while (!h.empty()) {
        int i = h.front();
        h.pop();
        for (auto& j : e) {
        if (j.first == i && g[j.second] < 0) {
        int k = f;
        if (d[j.second] == 1) {
        k = f;
        }
        if (g[i] > 0) {
       g[j.second] = k - 1;
        h.push(j.second);
                }
            }
        }
    }
    
    return g[c] >= 0; 
}

int energy_nodes(int a, int b, int c, vector<int>& d, vector<pair<int, int>>& e) {
    int f = 1, g = b, h = -1; 
    while (f <= g) {
        int i = f + (g - f) / 2; 
        if (ss(a, c, b, d, i)) {
            h = i; 
            g = i - 1;
        } else {
            f = i + 1; 
        }
    }
    return h;
}

from bisect import bisect_left, bisect_right

class Solution:
    def minTime(self, start, end, q_start, q_end, k):
        events = [(s, 1) for s in start] + [(e + 1, -1) for e in end]
        events.sort()

        intervals, cnt, prev = [], 0, None
        for t, typ in events:
            if prev is not None and cnt >= k:
                intervals.append((prev, t))
            cnt += typ
            prev = t

        starts = [s for s, _ in intervals]
        ends = [e for _, e in intervals]
        pre = [0] * len(ends)
        total = 0
        for i in range(len(intervals)):
            total += ends[i] - starts[i]
            pre[i] = total

        res = []
        for qs, qe in zip(q_start, q_end):
            l = bisect_left(ends, qs)
            r = bisect_right(starts, qe) - 1
            if l > r:
                res.append(0)
                continue

            overlap = pre[r] - (pre[l - 1] if l > 0 else 0)
            if starts[l] < qs:
                overlap -= qs - starts[l]
            if ends[r] > qe:
                overlap -= ends[r] - qe
            res.append(overlap)
        
        return res