// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int X, int[] A) {
        // write your code in Java SE 8
    }
}

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
}

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎ㅇ
}

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    
}

#ㅑㅜ치
int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간


}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간


}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> 

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;

    for(int i =0; i<A.size(); i++){
        
    }

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    int 
    for(int i =0; i<A.size(); i++){

    }

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    int X = A.size();

    
    for(int i =0; i<A.size(); i++){

    }

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true})
    }
    for(int i =0; i<A.size(); i++){

    }

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        if(leaf_map)
    }

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        if(leaf_map.empty()) return i;
    }

    return -

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        if(leaf_map.empty()) return i;
        
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        if(leaf_map.empty()) return i;
        
        if(leaf_map.find())
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        if(leaf_map.empty()) return i;
        
        if(leaf_map.find(i)) leaf_map.
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        if(leaf_map.empty()) return i;
        
        if(leaf_map.find(i)) leaf_map.erase(i);
        else 
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i;

        //위
        if(leaf_map.find(i)) leaf_map.erase(i);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(i)) leaf_map.erase(i);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i])) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) !) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i-1;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i-1;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i-1;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i-1;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i-1;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){
        //기저 사례
        if(leaf_map.empty()) return i-1;

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);

        /
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);

        if(leaf_map.empty()) return i;
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);

        if(leaf_map.empty()) return i;
    }

    return -1;

}

#include <iostream>
#include <unordered_map>
using namespace std;

int solution(int X, vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    //잎이 전체 위치에 존재하는 경우 가장 빠른 시간

    unordered_map<int, bool> leaf_map;
    for(int i = 1; i<= X; i++){
        leaf_map.insert({i,true});
    }
    for(int i =0; i<A.size(); i++){

        //해당 위치에 떨어진적 없는 잎이면
        if(leaf_map.find(A[i]) != leaf_map.end()) leaf_map.erase(A[i]);

        if(leaf_map.empty()) return i;
    }

    return -1;

}