Duże liczby i biblioteka GMP - problem z kompilacją(?)

#include <time.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <gmp.h>
using namespace std;

int main()
{
    // wyswietlenie czasu rozpoczecia
    time_t czas;
    struct tm * ptr;
    time( & czas );
    ptr = localtime( & czas );
    char * data = asctime( ptr );
    cout << endl;
    cout << "\t";
    cout << "Start: " << data;
   
    // zmienne do obliczenia czasu pojedynczej liczby
    time_t start, koniec;
    double roznica;
   
    mpz_t liczba;
    mpz_init_set_str( liczba, "500000000000000000000117", 10 );
    // Tu wstawiamy liczbe naturalna,
    // od ktorej chcemy zaczac szukanie.
   
    // Sprawiamy, ze liczba bedzie spelniala warunek 6k+1.
    mpz_t wynik6;
    mpz_init( wynik6 );
    mpz_t skok1;
    mpz_init_set_str( skok1, "1", 10 );
    mpz_t szostka;
    mpz_init_set_str( szostka, "6", 10 );
    mpz_cdiv_q( wynik6, liczba, szostka );
    mpz_mul( liczba, wynik6, szostka );
    mpz_add( liczba, liczba, skok1 );
   
    // Zmienne potrzebne do sprawdzenia podzielnosci
    mpz_t granica;
    mpz_init( granica );
    mpz_t dzielnik;
    mpz_init( dzielnik );
    mpz_t reszta;
    mpz_init( reszta );
    mpz_t zero;
    mpz_init_set_str( zero, "0", 10 );
   
    // Zmienne potrzebne do wyswietlania licznika.
    mpz_t podzielnik;
    mpz_init( podzielnik );
    mpz_t podzielnik2;
    mpz_init( podzielnik2 );
    mpz_t podzielnik3;
    mpz_init( podzielnik3 );
    mpz_t podzielnik4;
    mpz_init( podzielnik4 );
    mpz_t podzielnik5;
    mpz_init( podzielnik5 );
    mpz_t podzielnik6;
    mpz_init( podzielnik6 );
    mpz_t podzielnik7;
    mpz_init( podzielnik7 );
    mpz_t podzielnik8;
    mpz_init( podzielnik8 );
    mpz_t podzielnik9;
    mpz_init( podzielnik9 );
    mpz_t dwojka;
    mpz_init_set_str( dwojka, "2", 10 );
    mpz_t trojka;
    mpz_init_set_str( trojka, "3", 10 );
    mpz_t czworka;
    mpz_init_set_str( czworka, "4", 10 );
    mpz_t piatka;
    mpz_init_set_str( piatka, "5", 10 );
    mpz_t siodemka;
    mpz_init_set_str( siodemka, "7", 10 );
    mpz_t osemka;
    mpz_init_set_str( osemka, "8", 10 );
    mpz_t dziewiatka;
    mpz_init_set_str( dziewiatka, "9", 10 );
    mpz_t dziesiatka;
    mpz_init_set_str( dziesiatka, "10", 10 );
   
    int sprawdzenie = 0; // Zmienna do oznaczania pierwszosci.
   
    // sprawdzanie kolejnych liczb nieparzystych
    // spelniajacych zaleznosc 6k+1 (pozniej dodamy 6k-1)
    while( sprawdzenie == 0 )
    {
        cout << endl;
        gmp_printf( "Liczba: %Zd", liczba );
        cout << endl;
       
        // Zaczynamy pomiar czasu sprawdzania danej liczny.
        time( & start );
       
        sprawdzenie = 1; // zakladamy, ze liczba jest pierwsza
       
        // Wyznaczamy maksymalny mozliwy podzielnik.
        mpz_sqrt( granica, liczba );
        // Zaczynamy od sprawdzenia podzielnosci przez 3.
        mpz_set_str( dzielnik, "3", 10 );
       
        // Zerujemy licznik.
        int licznik = 1;
        // Obliczamy rozmiar krokow licznika
        mpz_cdiv_q( podzielnik, granica, dziesiatka );
        mpz_mul( podzielnik2, podzielnik, dwojka );
        mpz_mul( podzielnik3, podzielnik, trojka );
        mpz_mul( podzielnik4, podzielnik, czworka );
        mpz_mul( podzielnik5, podzielnik, piatka );
        mpz_mul( podzielnik6, podzielnik, szostka );
        mpz_mul( podzielnik7, podzielnik, siodemka );
        mpz_mul( podzielnik8, podzielnik, osemka );
        mpz_mul( podzielnik9, podzielnik, dziewiatka );
       
        // sprawdzanie podzielnosci danej liczby
        while( sprawdzenie == 1 && mpz_cmp( dzielnik, granica ) <= 0 )
        {
            if(
            mpz_cmp( podzielnik, dzielnik ) == 0 ||
            mpz_cmp( podzielnik2, dzielnik ) == 0 ||
            mpz_cmp( podzielnik3, dzielnik ) == 0 ||
            mpz_cmp( podzielnik4, dzielnik ) == 0 ||
            mpz_cmp( podzielnik5, dzielnik ) == 0 || // sprawdzanie licznika
            mpz_cmp( podzielnik6, dzielnik ) == 0 ||
            mpz_cmp( podzielnik7, dzielnik ) == 0 ||
            mpz_cmp( podzielnik8, dzielnik ) == 0 ||
            mpz_cmp( podzielnik9, dzielnik ) == 0
            )
            {
                cout << "\r" << licznik << "\/10 za nami"; // wyswietlanie licznika
                licznik = licznik + 1;
            }
           
            // Sprawdzenie podzielnosci i ewentualne wyswietlenie dzielnika.
            mpz_mod( reszta, liczba, dzielnik );
            if( mpz_cmp( reszta, zero ) == 0 )
            {
                gmp_printf( "\rDzielnik: %Zd", dzielnik );
                sprawdzenie = 0;
            }
            else { mpz_add( dzielnik, dzielnik, skok1 ); }
        }
       
        // Przechodzimy do nastepnej liczby nieparzystej
        // spelniajacej zaleznosc 6k+1
        // lub wyswietlamy "brak dzielnika"
        // oraz czas wykonania obliczen.
        if( sprawdzenie == 0 )
        {
            mpz_add( liczba, liczba, szostka );
        }
        else
        {
            gmp_printf( "\rBrak dzielnika" );
        }
        time( & koniec );
        roznica = difftime( koniec, start );
        cout << " | Czas: " << roznica << " s\n";
    }
   
    // Jesli trafimy na liczbe pierwsza, to ja wyswietlamy.
    if( sprawdzenie == 1 )
    {
        cout << endl;
        time( & czas );
        ptr = localtime( & czas );
        char * data = asctime( ptr );
        cout << "\t"; cout << "Koniec: " << data;
        cout << endl;
        cout << "\t";
        gmp_printf( "Ta liczba jest pierwsza: %Zd\n", liczba );
    }
    cout << endl;
   
    return 0;
}