how to make a c++ compile time calculation progamme recursion level deeper?

I have a programme that calculates all the prime numbers below N at compile time. For example, if I set N = 20, I'll get {2, 3, 5, 7, 11, 13, 17, 19}, if N = 10, I'll get {2, 3, 5, 7} I've tried N = 1499, and It worked, but no larger than 1499. If N = 1500, then "Fatal Error C1202 recursive type or function dependency context too complex" would come out...

PS:I'm using vs2019 with c++17, Debug mode and X86

Are there any ways to enlarge the N to perhaps 10000 or more ? (For msvc and gcc) Here is my code

#include <cstdlib>
#include <cstdio>
#include <utility>
 
static const int N = 1499;

constexpr bool IsPrime(int n)
{
    if (n > 6)
    {
        if (n % 6 != 1 && n % 6 != 5)
        {
            return false;
        }

        for (int i = 5; i * i < n; ++i)
        {
            if (n % i == 0)
            {
                return false;
            }
        }

        return true;
    }
    else if (n == 2 || n == 3 || n == 5)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <size_t...V>
struct is_prime_t
{
    bool is_prime[sizeof...(V)] = {
        IsPrime(V)...
    };
};

template <size_t...V>
constexpr is_prime_t <V...> GetIsPrime_T(std::index_sequence<V...>)
{
    return is_prime_t<V...>();
};

static constexpr auto is_prime_list = GetIsPrime_T(std::make_index_sequence<N>());

constexpr auto GetNextPrime(int prime)
{
    for (int i = prime - 1; i >= 0; --i)
    {
        if (is_prime_list.is_prime[i]) return i;
    }

    return 0;
}

template <size_t...V>
struct prime_list_t
{
    size_t prime_list[sizeof...(V)] = {
        V...
    };
};

template <bool, size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker;

template <size_t N, size_t... Primes>
struct prime_sequence_helper
{
    typedef typename prime_sequence_helper_with_checker<IsPrime(N), N, Primes...>::type type;
};

template <size_t... Primes>
struct prime_sequence_helper<0, Primes...>
{
    typedef typename prime_list_t<Primes...> type;
};

template <size_t N>
struct prime_sequence
{
    typedef typename prime_sequence_helper<N>::type type;
};

template <bool, size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker;

template <size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker<true, N, Primes...>
{
    //typedef typename prime_sequence_helper<N - 1, N, Primes...>::type type;
    typedef typename prime_sequence_helper<GetNextPrime(N), N, Primes...>::type type;
};

template <size_t N, size_t... Primes>
struct prime_sequence_helper_with_checker<false, N, Primes...>
{
    //typedef typename prime_sequence_helper<N - 1, Primes...>::type type;
    typedef typename prime_sequence_helper<GetNextPrime(N), Primes...>::type type;
};

template <size_t N>
constexpr auto GetPrimeList_T()
{
    return prime_sequence<N>::type();
}


int main()
{    
    constexpr auto prime_list = GetPrimeList_T<N>();

    system("pause");
    return 0;
}