#include <bits/stdc++.h>
using namespace std;
long long powN(long long a, long long p) {
  if (p == 0) return 1;
  long long z = powN(a, p / 2);
  z = (z * z) % 1000000007;
  if (p % 2) z = (z * a) % 1000000007;
  return z;
}
long long powN(long long a, long long p, long long md) {
  if (p == 0) return 1;
  long long z = powN(a, p / 2, md);
  z = (z * z) % md;
  if (p % 2) z = (z * a) % md;
  return z;
}
long long modinverse(long long n, long long p) { return (powN(n, p - 2)); }
long long ncr(long long n, long long r) {
  long long p = 1000000007;
  if (r == 0) return 1;
  long long fac[n + 1];
  fac[0] = 1;
  for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
  return ((fac[n] * (modinverse(fac[r], p) % p)) % p *
          modinverse(fac[n - r], p) % p) %
         p;
}
long long int parent[200005];
long long int ssize[200005];
void make_set(int v) {
  parent[v] = v;
  ssize[v] = 1;
}
int find_set(int v) {
  if (v == parent[v]) return v;
  return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
  a = find_set(a);
  b = find_set(b);
  if (a != b) {
    if (ssize[a] < ssize[b]) swap(a, b);
    parent[b] = a;
    ssize[a] += ssize[b];
  }
}
typedef struct Edge {
  long long int u, v, weight;
  bool operator<(Edge const& other) { return weight < other.weight; }
} edge;
int r[200005];
bool prime[200005];
void sieve(long long int n) {
  for (long long int i = 1; i <= n; ++i) prime[i] = true;
  prime[1] = prime[0] = false;
  r[1] = 1;
  for (long long int i = 2; i <= n; ++i) {
    if (prime[i]) {
      r[i] = i;
      for (long long int j = i; i * j <= n; ++j) {
        if (prime[j * i]) r[j * i] = i;
        prime[j * i] = false;
      }
    }
  }
}
typedef struct {
  int t, C[3];
} pt;
int n;
void add(int id, long long int val, long long int BIT[]) {
  while (id <= n) {
    BIT[id] += val;
    id = id + (id & (-id));
  }
}
long long int query(int id, long long int BIT[]) {
  long long int result = 0;
  while (id > 0) {
    result += BIT[id];
    id = id - (id & (-id));
  }
  return (result);
}
long long P[100001], Q[100001], T[100001], H[100001], Stay[100001];
vector<bool> visited(100001, false);
bool final_ans = true;
long long int dfs(int v, vector<int> adj[]) {
  visited[v] = true;
  long long z = T[v];
  for (long long int i = 0; i < int((adj[v]).size()); ++i) {
    int u = adj[v][i];
    if (!visited[u]) {
      z = z + dfs(u, adj);
    }
  }
  T[v] = z;
  if (((z + H[v]) % 2 == 1) || (z < H[v]))
    final_ans = false;
  else {
    P[v] = (H[v] + z) / 2;
    Q[v] = (z - H[v]) / 2;
  }
  return (z);
}
void bfs(int v, vector<int> adj[], int n) {
  queue<int> q;
  q.push(v);
  vector<bool> visited(n + 1, false);
  visited[v] = true;
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    long long m = P[u];
    long long r = 0;
    long long a = Q[u];
    long long b = 0;
    for (int i = 0; i < int((adj[u]).size()); ++i) {
      int v = adj[u][i];
      if (!visited[v]) {
        q.push(v);
        visited[v] = true;
        r = r + P[v];
        b = b + Q[v];
      }
    }
    long long leftp = min(m - r, Stay[u]);
    long long leftq = Stay[u] - leftp;
    if (r > m || a - leftq > b) final_ans = false;
    if (b + r > T[u] - Stay[u]) final_ans = false;
  }
}
int main() {
  int t = 1;
  while (t--) {
    int n = 1;
    cin >> n;
    string s;
    cin >> s;
    int index = -1;
    for (long long int i = 0; i < n - 1; ++i) {
      if (s[i] > s[i + 1]) {
        index = i;
        break;
      }
    }
    if (index < 0) index = n - 1;
    for (long long int i = 0; i < n; ++i) {
      if (i != index) cout << s[i];
    }
    cout << endl;
  }
}

### Prompt

Construct a cpp code solution to the problem outlined:

You are given a string s consisting of n lowercase Latin letters.

You have to remove at most one (i.e. zero or one) character of this string in such a way that the string you obtain will be lexicographically smallest among all strings that can be obtained using this operation.

String s = s_1 s_2 ... s_n is lexicographically smaller than string t = t_1 t_2 ... t_m if n < m and s_1 = t_1, s_2 = t_2, ..., s_n = t_n or there exists a number p such that p ≤ min(n, m) and s_1 = t_1, s_2 = t_2, ..., s_{p-1} = t_{p-1} and s_p < t_p.

For example, "aaa" is smaller than "aaaa", "abb" is smaller than "abc", "pqr" is smaller than "z".

Input

The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of s.

The second line of the input contains exactly n lowercase Latin letters — the string s.

Output

Print one string — the smallest possible lexicographically string that can be obtained by removing at most one character from the string s.

Examples

Input


3
aaa


Output


aa


Input


5
abcda


Output


abca

Note

In the first example you can remove any character of s to obtain the string "aa".

In the second example "abca" < "abcd" < "abcda" < "abda" < "acda" < "bcda".

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
long long powN(long long a, long long p) {
  if (p == 0) return 1;
  long long z = powN(a, p / 2);
  z = (z * z) % 1000000007;
  if (p % 2) z = (z * a) % 1000000007;
  return z;
}
long long powN(long long a, long long p, long long md) {
  if (p == 0) return 1;
  long long z = powN(a, p / 2, md);
  z = (z * z) % md;
  if (p % 2) z = (z * a) % md;
  return z;
}
long long modinverse(long long n, long long p) { return (powN(n, p - 2)); }
long long ncr(long long n, long long r) {
  long long p = 1000000007;
  if (r == 0) return 1;
  long long fac[n + 1];
  fac[0] = 1;
  for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
  return ((fac[n] * (modinverse(fac[r], p) % p)) % p *
          modinverse(fac[n - r], p) % p) %
         p;
}
long long int parent[200005];
long long int ssize[200005];
void make_set(int v) {
  parent[v] = v;
  ssize[v] = 1;
}
int find_set(int v) {
  if (v == parent[v]) return v;
  return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
  a = find_set(a);
  b = find_set(b);
  if (a != b) {
    if (ssize[a] < ssize[b]) swap(a, b);
    parent[b] = a;
    ssize[a] += ssize[b];
  }
}
typedef struct Edge {
  long long int u, v, weight;
  bool operator<(Edge const& other) { return weight < other.weight; }
} edge;
int r[200005];
bool prime[200005];
void sieve(long long int n) {
  for (long long int i = 1; i <= n; ++i) prime[i] = true;
  prime[1] = prime[0] = false;
  r[1] = 1;
  for (long long int i = 2; i <= n; ++i) {
    if (prime[i]) {
      r[i] = i;
      for (long long int j = i; i * j <= n; ++j) {
        if (prime[j * i]) r[j * i] = i;
        prime[j * i] = false;
      }
    }
  }
}
typedef struct {
  int t, C[3];
} pt;
int n;
void add(int id, long long int val, long long int BIT[]) {
  while (id <= n) {
    BIT[id] += val;
    id = id + (id & (-id));
  }
}
long long int query(int id, long long int BIT[]) {
  long long int result = 0;
  while (id > 0) {
    result += BIT[id];
    id = id - (id & (-id));
  }
  return (result);
}
long long P[100001], Q[100001], T[100001], H[100001], Stay[100001];
vector<bool> visited(100001, false);
bool final_ans = true;
long long int dfs(int v, vector<int> adj[]) {
  visited[v] = true;
  long long z = T[v];
  for (long long int i = 0; i < int((adj[v]).size()); ++i) {
    int u = adj[v][i];
    if (!visited[u]) {
      z = z + dfs(u, adj);
    }
  }
  T[v] = z;
  if (((z + H[v]) % 2 == 1) || (z < H[v]))
    final_ans = false;
  else {
    P[v] = (H[v] + z) / 2;
    Q[v] = (z - H[v]) / 2;
  }
  return (z);
}
void bfs(int v, vector<int> adj[], int n) {
  queue<int> q;
  q.push(v);
  vector<bool> visited(n + 1, false);
  visited[v] = true;
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    long long m = P[u];
    long long r = 0;
    long long a = Q[u];
    long long b = 0;
    for (int i = 0; i < int((adj[u]).size()); ++i) {
      int v = adj[u][i];
      if (!visited[v]) {
        q.push(v);
        visited[v] = true;
        r = r + P[v];
        b = b + Q[v];
      }
    }
    long long leftp = min(m - r, Stay[u]);
    long long leftq = Stay[u] - leftp;
    if (r > m || a - leftq > b) final_ans = false;
    if (b + r > T[u] - Stay[u]) final_ans = false;
  }
}
int main() {
  int t = 1;
  while (t--) {
    int n = 1;
    cin >> n;
    string s;
    cin >> s;
    int index = -1;
    for (long long int i = 0; i < n - 1; ++i) {
      if (s[i] > s[i + 1]) {
        index = i;
        break;
      }
    }
    if (index < 0) index = n - 1;
    for (long long int i = 0; i < n; ++i) {
      if (i != index) cout << s[i];
    }
    cout << endl;
  }
}

```