# 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

#include <iostream>
#include <vector>
#include <unordered_map>
#include <string>

using namespace std;

class HMap {
private:
    unordered_map<long long, long long> m;
    long long a;
    long long b;

public:
    HMap() : a(0), b(0) {}

    void insert(long long x, long long y) {
        m[x - a] = y - b;
    }

    long long get(long long x) {
        long long k = x - a;
        if (m.find(k) != m.end()) {
            return m[k] + b;
        }
        return 0;
    }

    void addToKey(long long x) {
        a += x;
    }

    void addToValue(long long y) {
        b += y;
    }
};

long long solution(vector<string> qType, vector<vector<int>> q) {
    HMap h;
    long long s = 0;

    for (size_t i = 0; i < qType.size(); i++) {
        if (qType[i] == "insert") {
            h.insert(q[i][0], q[i][1]);
        } else if (qType[i] == "get") {
            s += h.get(q[i][0]);
        } else if (qType[i] == "addToKey") {
            h.addToKey(q[i][0]);
        } else if (qType[i] == "addToValue") {
            h.addToValue(q[i][0]);
        }
    }

    return s;
}

#include <bits/stdc++.h>
using namespace std;
int overlap(string a, string b) {
    int m = a.length(), n = b.length();
    int v = 0;
        for (int i = 1; i <= min(m, n); i++) {
        if (a.substr(m - i) == b.substr(0, i)) {
            v = i;
        }
    }
    return v;
}

int maxScore(int N, vector<string>& LIST, vector<int>& POINTS, int limit) {
    vector<int> dp(limit + 1, 0); 
    for (int i = 0; i < N; i++) {
        int len = LIST[i].length();
        int points = POINTS[i];
        for (int j = len; j <= limit; j++) {
            dp[j] = max(dp[j], dp[j - len] + points);
        }
        for (int k = 0; k < N; k++) {
            if (i == k) continue; 
            int ov = overlap(LIST[i], LIST[k]);
            int new_len = len + LIST[k].length() - ov;
            int new_points = points + POINTS[k];
            for (int j = new_len; j <= limit; j++) {
                dp[j] = max(dp[j], dp[j - new_len] + new_points);
            }
        }
    }
    return dp[limit];
}