#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <cmath>
using namespace __gnu_pbds;
using namespace std;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;

typedef long long lli;
typedef long li;
typedef pair<int,int> PI;
typedef pair<long,int> PLI;
typedef pair<int,long> PIL;
typedef pair<long, long> PL;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<long> VL;
typedef vector<long long> VLL;
typedef priority_queue<int> PQ;
typedef priority_queue<long> PQL;
typedef priority_queue<long long> PQLL;
#define FAST ios::sync_with_stdio(0)
#define forz(n) for (long i = 0; i < n; i++)
#define forv(i,x,y) for (long i=x; i<y; i++)
#define rforz(a,n) for (long i = a; i < n; i++)
#define forlz(n) for (long int i = 0; i < n; i++)
#define TRAV(it, v) for(auto it = v.begin(); it != v.end(); it++) 
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define SQ(a) (a)*(a)
#define UM unordered_map
#define US unordered_set
#define LB(v,x) lower_bound(v.begin(),v.end(),x);
#define UB(v,x) upper_bound(v.begin(),v.end(),x);
#define CUBE(a) (a)*(a)*(a)
#define SORT(v) sort(v.begin(),v.end());
#define SORTC(v,c) sort(v.begin(),v.end(),c);
#define Pi 3.14159265358979323846


#define module 1000000007


lli gcd(lli x,lli y){
    if(x==0) return y;
    return gcd(y%x,x);
}
 
PL Egcd(lli x,lli y){
    if(x==0) return MP(0,1);
    PL t=Egcd(y%x,x);
    return MP(t.S-t.F*(y/x),t.F);
}


lli powerget(lli y, lli x,lli md) { 
    lli temp; 
    if( y == 0) 
        return 1; 
    temp = powerget(y/2, x, md); 
    if (y%2 == 0) 
        return (temp*temp)%md; 
    else{
        lli t = (temp*temp)%md;
        t = t;
        return (x*t)%md; 
    }
} 

vector<PLL> primeDivisor(lli x){
    if(x<=3){
        vector<PLL> r ;
        r.PB(MP(x,1));
        return r;
    }
    lli n = floor(sqrt(x));
    vector<PLL> res;
    for(lli i=2;i<=n;i++){
        if(x%i == 0){
            res.push_back(MP(i,1));
        }
        int zz=0;
        while(x%i == 0){
            zz++;
            x = x/i;
            res[res.size()-1].S = zz;
        }
        
        if(x<2){
            break;
        }

    }
    if(x>2){
        res.push_back(MP(x,1));
    }
    return res;
}

struct edges{
    int e,u,v;
};

int root(int v,vector<int> &parent){
    if(v == parent[v]){
        return v;
    }
    return parent[v] = root(parent[v],parent);
}

void union_set(int x,int y,vector<int> &parent,vector<int> &rank){
    x = root(x,parent);
    y = root(y,parent);
    if(x != y){
        if(rank[x]<rank[y]){
            swap(x,y);
        }
        parent[y] = x;
        if(rank[x] == rank[y]){
            rank[x]++;
        }
    }
}
int kruskals(vector<edges> graph,vector<int> vis,vector<int> &id,vector<int> &rank){
    // vector<edges> res;
    int res=0;
    for(edges x:graph){
        int e = x.e;
        int u = x.u;
        int v = x.v;
        // if(vis[u] && vis[v]) continue;
        if(root(u,id)!=root(v,id)){
            vis[u] = 1;
            vis[v] = 1; 
            union_set(u,v,id,rank);
            // res.push_back(x);
            // res+=e;
        }
        
    }
    // bool connected=true;
    // for(int i=1;i<vis.size();i++){
    //     if(vis[i]==0){
    //         connected = false;
    //         break;
    //     }
    // // }
    // if(true){
    //     return res;
    // }
    // vector<edges> nl;
    // return nl;
    return res;
}
li b_search(lli arr[],lli key,li n){
    li k=0;
    // li n = (*(&arr + 1) - arr);
    // lli n = sizeof(arr)/sizeof(arr[0]);
    for(li b = n/2 ; b>0; b /= 2){
        while(k+b <n && arr[k+b]<=key) k+= b;
    }
    if(arr[k]==key){
        return k;
    }else{
        return -1;
    }
}
lli bfs(lli s,lli e, vector<lli> g[],vector<int> &vis){
    lli n = vis.size();
    vector<lli> parent(n);
    queue<int> q;
    q.push(s);
    vis[s] = 1;
    bool flag=false;
    lli count=0;
    // vector<int> prev(n+1,0);
    while(!q.empty()){
        int node = q.front();
        q.pop();
        for(int x:g[node]){
            if(vis[x]) continue;
            q.push(x);
            vis[x] = 1;
            parent[x] = node;
            if(x==e){
                flag = true;
                break;
            }
            // prev[x] = node;
        }
        if(flag){
            break;
        }
    }
    if(flag){
        lli j = e;
        while(e!=s){
            e = parent[e];
            count++;
        }
        return count;
    }else{
        return (lli)0;
    }
    
}
li max_subarray_sum(VL &arr){
    li  l= arr.size();
    li sum=0,best=0;
    forz(l){
        sum = max(arr[i],arr[i]+sum);
        best = max(sum,best);
    }
    return best;
}
string generate_ternary(lli n){
    string str = "";
    int t,index=0;
    int i=0;
    while(n>0){
        t = n%3;
        i++;
        if(n==2){
            index=i;
        }
        str+= (t+'0');
        n/=3;
    }
    reverse(str.begin(),str.end());
    return str;
}
string cal(PL a){
    string str="";
    li x = a.F;
    li y = a.S;
    while(x){
        int temp = x%10;
        str += temp + '0';
        x/= 10;
    }
    reverse(str.begin(),str.end());
    while(y){
        int temp = y%10;
        str += temp + '0';
        y/= 10;
    }
    return str;
}
string decimal_to_binary(lli n){
    int t = 0;
    lli tt = n;
    while(tt>0){
        t++;
        tt /= 2;
    }
    bitset<32> s = bitset<32>(n);
    string str = "";
    forz(s.size()){
        str += s[i]+'0';
    }
    reverse(str.begin(),str.end());
    return str;
}
lli find_combination(lli n,lli k){
    if(n<k){
        return 0;
    }else if(n==k){
        return 1;
    }else if(k==0){
        return 1;
    }
    return find_combination(n-1,k) + find_combination(n-1,k-1);

}
lli nC2 (lli n){
    return (n*(n-1))/2;
}
bool checkPrime(lli x){
    if(x==1){
        return false;
    }
    if(x<=3){
        return true;
    }
    li t=2;
    if(x%2 == 0){
        return false;
    }
    t=3;
    for(t;t<=sqrt(x);t+=2){
        if(x%t ==0){
            return false;
        }
    }
    return true;
}
lli cal(int s,lli x){
    return x*(x+s);
}
int sx(lli a){
    int count=0;
    while(a>0){
        count++;
        a = a/10;
    }
    return count;
}
int differ(lli n,lli x){
    string str1 = to_string(n);
    string str2 = to_string(x);
    int count=0;
    forz(str1.length()){
        if(str1[i]!=str2[i]){
            break;
        }
        count++;
    }
    return count;
}
string convert(lli n,int d){
    string str = to_string(n);
    while(str.length() < d){
        str  = "0" + str;
    }
    return str;
}
lli string_to_lli(string s){
    lli t=0;
    for(char x:s){
        t = t*10 + (x-'0');
    }
    return t;
}
bool poss(vector<lli> a,int s,int t,int i){
    if(t==s){
        return true;
    }else if(i>3){
        return false;
    }else{
        return  poss(a,s,t+a[i],i+1) || poss(a,s,t,i+1);
    }
}
void findAllSum(vector<int> arr,int n,set<int> &all,int x){
    if(n==0){
        all.insert(x);
        return;
    }
    else {
        findAllSum(arr,n-1,all,x+arr[n-1]);
        findAllSum(arr,n-1,all,x);
        return;
    }
}
bool sumPossible(vector<lli> arr,int n){
    int pos[arr.size()+1][n+1];
    forz(arr.size()+1){
        forv(j,0,n+1){
            pos[i][j] = 0;
        }
    }
    pos[0][0]=1;
    rforz(1,n+1){
        // pos[i][0]=1;
        forv(j,0,arr.size()){
            if(j-arr[i]>=0) pos[j][i] |= pos[j-arr[i]][i];
            pos[j][i] |= pos[j][i-1];
        }
    }
    return pos[n][arr.size()-1]>0;
}
int minQuery(int a,int b,vector<int> v[]){
    if(a==b){
        return v[a][0];
    }
    int k = (b-a+1);
    int t= floor(log(k)/log(2));
    int count=k;
    t = (1<<t);
    // while(t<k){
    //     t *= 2;
    //     count++;
    // }

    if(t!=k){
        t = t/2;
        count--;
    }
    return min(v[a][count],v[b-t+1][count]);
}
// lli n,m;
// bool is_valid(int x,int y){
//     if(x>= 0 && x<m && y>=0 && y<n){
//         return true;
//     }else{
//         return false;
//     }
// }
// bool bfs2(vector<char> arr[],vector<int> vis[],PI a){
//     vector<int> xmove = {1,0,-1,0};
//     vector<int> ymove = {0,-1,0,1};
//     queue<PI> q;
//     q.push(a);
//     vis[a.F][a.S] = 1;
//     while(!q.empty()){
//         PI p = q.front();
//         q.pop();
//         if(vis[p.F][p.S]) continue;
//         vis[p.F][p.S] = 1;
//         forz(4){
//             if(is_valid(p.F + xmove[i],p.S + ymove[i]) ){
//                 if(vis[p.F + xmove[i]][p.S + ymove[i]] || (arr[p.F + xmove[i]][p.S + ymove[i]] != arr[a.F][a.S])) continue;
//                 q.push(MP(p.F + xmove[i],p.S + ymove[i]));
//             }
//         } 
//     }
// }



bool check(vector<lli> &a,vector<lli> &b,lli k){

}

li fenwikTree(vector<lli> &arr,long k){
    long sum=0;
    while(k>=1){
        sum+=arr[k];
        k -= (~(k-1))&k ; 
    }
    return sum;
}
void fenwikTreeUpdate(vector<lli> &arr,long k,long x){
    while(k<=arr.size()){
        arr[k] += x;
        k += (~(k-1))&k;
    }
}

lli n,m;
bool valid_dir(int x,int y){
    if(x>=0 && x<n && y<=0 && y<m){
        return true;
    }else{
        return false;
    }
}
bool comp(PLL a,PLL b){
    return (a.F - a.S)  >= (b.F - b.S);
}
bool isChar(char x){
    if((x-'A' >=0 && x-'A'< 26) || (x-'a' >=0 && x-'a'<26)){
        return true;
    }
    return false;
}


bool dfs2(vector<char> arr[],vector<int> vis[],int i,int j,int prevx,int prevy){
    if(!valid_dir(i,j)) return false;
    if(vis[i][j]==1) return true;
    if(vis[i][j]==2) return false;
    int xdir[] = {1,0,-1,0};
    int ydir[] = {0,-1,0,1};
    vis[i][j] = 1;

}

void solve(){
    
    cin>>n>>m;
    vector<char> arr[n];
    vector<int> vis[n];
    string str;
    forz(n){
        cin>>str;
        forv(j,0,m){
            arr[i].PB(str[j]);
            vis[i].PB(0);
        }
    }
    

    forz(n){
        forv(j,0,m){
            if(vis[i][j]) continue;
            // dfs2(arr,vis,i,j);

        }
    }
    
    return;
}


int main(){
    FAST;
    cin.tie(0);
    cout.tie(0);
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    //=====================================code starts here
    lli n;
    cin>>n;
    vector<lli> arr(n);
    lli index=-1;
    forz(n){
        cin>>arr[i];
        if(arr[i] ==1) index=i;
    }
    if(index == -1){
        cout<<index<<'\n';
    }else{
        lli count =2;
        index++;
        while(index<n){
            if(arr[index]==count){
                count++;
            }
            index++;
        }
        cout<<(n +1 - count)<<"\n";
    }
    return 0;
}



Measured memory_bytes: 1792