#include <bits/stdc++.h>

using namespace std;
typedef long long lli;
typedef unsigned long long int uli;
typedef long double Lf;

#define fastIO  std::ios::sync_with_stdio(false);cin.tie(NULL)
#define mod 1000000007
#define BIGE = 999999999999999999LL
#define N 200005
#define NN 25
#define SZ(x) ((lli) (x).size())
#define vi vector<int>
#define ii <int, int>
#define ll <long, long>
#define lll <long long, long long>
#define loop(i,s,n) for(int (i)=(s);(i)<(n);(i)++)
#define loopr(i,n,s) for(int (i)=(n)-1;(i)>=(s);(i)--)
#define pb push_back
#define o2(a,b) cout<<(a)<<" "<<(b)<<endl
#define o3(a,b,c) cout<<(a)<<" "<<(b)<<" "<<(c)<<endl
#define o4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define cl cout<<endl
#define r0 return 0
#define x first
#define y second


inline lli modadd(lli n,lli m,lli p=mod){
    return ((n+m)%p+p)%p;
}

inline lli modsub(lli n,lli m,lli p=mod){
    return ((n-m+p)%p+p)%p;
}

inline lli modpro(lli n,lli m,lli p=mod){
    return ((n*m)%p+p)%p;
}










inline uli powe(lli x,lli y){
    uli res = 1;
    while (y > 0) {
        if (y & 1)
            res = res * x;
        y = y >> 1;
        x = x * x;
    }
    return res;
}



inline lli powmod(lli x,lli y,lli p=mod){
    lli res = 1;
    while (y > 0) {
        if (y & 1)
            res = modpro(res , x, p);
        y = y >> 1;
        x = modpro(x , x, p);
    }
    return res;
}

inline lli modadd3(lli x, lli y, lli z,lli p=mod){
    return modadd(modadd(x,y,p),z,p);
}

inline lli modadd4(lli x, lli y, lli z, lli w,lli p=mod){
    return modadd(modadd(x,y,p),modadd(z,w,p),p);
}

template <typename T>
inline T max3(T x, T y, T z){
    return max(max(x,y),z);
}

template <typename T>
inline T max4(T x, T y, T z, T w){
    return max(max3(x,y,w),z);
}

template <typename T>
inline T min3(T x, T y, T z){
    return min(min(x,y),z);
}

template <typename T>
inline T min4(T x, T y, T z, T w){
    return min(min3(x,y,w),z);
}


template <typename T>
void printArr(T *arr, int n){
    for(int i=0;i<n;i++){

        cout<<arr[i]<<" ";
    }cout<<endl;
}




template <typename T>
T gcd(T a, T b)
{
    if (a == 0)
        return b;
    if(b==0)
        return a;
    T t;
    while((a>0)&&(b>0)){
     t = a;
     a=b%a;
     b=t;
 }

 return max(a,b);
}
//


//
//uli choose(uli n, uli k){
//uli res = 1;
//
//    // Since C(n, k) = C(n, n-k)
//    if ( k > n - k )
//        k = n - k;
//
//    // Calculate value of
//    // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
//    for (uli i = 0; i < k; ++i)
//    {
//        res *= (n - i);
//        res /= (i + 1);
//    }
//
//    return res;
//}
//

//vector<int> adj[N];
//bool visited[N];
////queue<int> q;
////int color[N];
//
//class Graph{
//
// public:
//    int V;
//
//
//
//    Graph(int V)
//{
//    this->V = V;
//
//}
//
//    void addEdge(int a, int b)
//{
//    //adj[b].pb(a);
//    adj[a].pb(b);
//}
//
////void dfs(int x){
////    visited[x]=1;
////    for(auto u:adj[x]){
////        if(!visited[u]){
////            dfs(u);
////        }
////    }
////}
//
////void dfsTree(int x, int p){
////    for(int u:v[x]){
////        if(u!=p) dfs(u,x);
////    }
////
////}
//
//
//
////void bfs(int x){
////    visited[x]=1;
////    q.push(x);
////    while(!q.empty())
////    {
////        int s = q.front();
////        q.pop();
////
////        for(int u : v[s]){
////            if(visited[u]==1) continue;
////            visited[u]=1;
////            //cout<<u<<endl;
////            q.push(u);}}}
//
////int connectedcomponents(int n){
////    int ans=0;
////    loop(i,1,n+1){
////        if(!visited[i]){
////            ans++;
////            dfs(i);
////        }
////
////    }
////    return ans;
////}
//
//};


//
//
//vector<int> parent, rank_;
//
//void makeSet(int x){
//	parent[x]=x;
//	rank_[x]=0;
//}
//
//int findSet(int x){
//	if(x!=parent[x])
//		parent[x]=findSet(parent[x]);
//
//	return parent[x];
//}
//
//void unionSets(int x, int y){
//	int px = findSet(x);
//	int py = findSet(y);
//
//	if(rank_[px]<rank_[py]){
//		parent[px]=py;
//		mm[py]=max(mm[px],mm[py]);
//	}
//	else if(rank_[py]<rank_[px]){
//		parent[py]=px;
//		mm[px]=max(mm[px],mm[py]);
//	}
//	else{
//		parent[py]=px;
//		mm[px]=max(mm[px],mm[py]);
//		rank_[px]++;
//	}
//
//}
//










//
//template <typename T>
//T findpowerfactorial(T n,T p)
//{
//    T x = 0;
//    while (n)
//    {
//        n /= p;
//        x += n;
//    }
//    return x;
//}
//
//template <typename T>
//int getibit(T n, int i){
//    //cout<<(n&(1LL<<i))<<endl;
//    return (n&(1LL<<i))?1:0;
//}
//
//template <typename T>
//int findbits(T n, T p){
//    int x=0;
//    while(n>0){
//        n/=p;
//        x++;
//    }
//    return x;
//}
//
//
//void primeFactors(int n)
//{
//    while (n % 2 == 0)
//    {
//        cout << 2 << " ";
//        n = n/2;
//    }
//
//
//    for (int i = 3; i <= sqrt(n); i = i + 2)
//    {
//        while (n % i == 0)
//        {
//            cout << i << " ";
//            n = n/i;
//        }
//    }
//    if (n > 2)
//        cout << n << " ";
//}
//
//
//
//



// bool c2(pair<lli, lli> p, pair<lli, lli> q){
// 	return p.x<q.x||((p.x==q.x)&&(p.y>q.y));
// }


//vll v[4];
//
//lli gcd(lli a, lli b){
//    int ta=max(a,b),tb=min(a,b);
//int tr,td;
//    while(ta>0&&tb>0){
//
//        tr = ta%tb;
//        td = ta/tb;
//        o4(ta,tb,tr,td);cout<<"x";
//        v[0].pb(ta);v[1].pb(td);v[2].pb(tb);v[3].pb(tr);
//        ta=tb;
//        tb=tr;
//
//    }
//    return max(ta,tb);
//}
//
//




//lli gcd(lli a, lli b)
//{
//    if (a == 0)
//        return b;
//    if(b==0)
//        return a;
//    lli t;
//    while((a>0)&&(b>0)){
//     t = a;
//     tr = b%a;
//
//     a=b%a;
//     b=t;
// }
//
// return max(a,b);
//}



// Returns n^(-1) mod p
//int modInverse(int n, lli p)
//{
//    return powmod(n, p-2, p);
//}
//
//
//lli fac[N];
//void facinit(int n){
//    fac[0]=1;
//    for (int i=1 ; i<=n; i++)
//        fac[i] = fac[i-1]*i%mod;
//}
//int nCrModPFermat(int n, int r, lli p)
//{
//   // Base case
//   if (r==0)
//      return 1;
//
//
//    return (fac[n]* modInverse(fac[r], p) % p *
//            modInverse(fac[n-r], p) % p) % p;
//}


/*BITMASK
for( int inum = 0 ; inum < ( 1 << n ) ; ++ inum ) {
                 for ( int pos = 0; pos < n ; ++pos ) {
                     if ( ( inum & ( 1 << pos ) ) != 0 )
                          results[inum] += s [pos] ; //DO SOMETHING
                     }
                 }

*/

int main(){
    //fastIO;
    int erer=1;
    //cin>>erer;
    loop(erer2,1,erer+1){
        int n;
        cin>>n;
        int a[N];
        loop(i,0,n)cin>>a[i];
        int itr=1;
        loop(i,0,n){
            if(a[i]==itr){
                itr++;
            }
        }
        if(itr==1) cout<<-1;
        else cout<<(n-itr+1)<<endl;
    }
    return 0;
}


Measured memory_bytes: 1024