// compile next key as defined by NIST
        block_xor(key, ct + 2 * blen - klen, klen);
    }
}

// Synchronise two comparison files if they get out of step

int sync(int nbr, ifstream& inf, char str[], bool outp)
{   line_type   ty;
    int         nn;

    for(;;)
    {
        ty = find_line(inf, str);

        if(ty == bad_line) return -1;

        if(ty == test_no)
        {
            nn = get_dec(str + 2);

            if(nn >= nbr) return nn;
        }

        if(outp) cout << "\n  " << str;
    }
}

// Compare two test vector files

void comp_vecs(const char *fn1, const char *fn2)
{   char       str1[128], str2[128];
    line_type  ty1, ty2;
    int        no1, no2, err_cnt, np_cnt;
    bool       req;
    ifstream   if1;
    ifstream   if2;

    err_cnt = np_cnt = 0; req = true;

    if1.open(fn1, ios::in);

    if(!if1)   // open first file
    {
        cout << "\n*** 1st file (" << fn1 << ") not found ***"; return;
    }

    if2.open(fn2, ios::in);

    if(!if2)   // open second file
    {
        cout << "\n*** 2nd file (" << fn2 << ") not found ***"; return;
    }

    for(;;)         // while there is still input
    {
        if(req)     // if another line needs to be input
        {
            ty1 = find_line(if1, str1); ty2 = find_line(if2, str2);
        }

        if(ty1 == bad_line && ty2 == bad_line)      // if end of file on both files

            break;

        if(ty1 == bad_line || ty2 == bad_line)      // if end of file on one file
        {
            cout << '\n' << fn1 << (ty1 == bad_line ? " short" : " long")
                                                << "er than " << fn2;
            break;
        }

        if(ty1 == test_no)          // if 'test number' line in file 1

            no1 = get_dec(str1);

        if(ty2 == test_no)          // if 'test number' line in file 2

            no2 = get_dec(str2);

        if(cmp_nocase(str1, str2) == 0)
        {
            req = true; continue;   // if lines are the same continue
        }

        if(ty1 == test_no && ty2 == test_no)    // if not the same but both are at a
        {                                       // 'test number' line
            np_cnt += abs(no2 - no1); req = false;

            if(no2 < no1)   // extra tests in file 2
            {
                cout << "\nextra test(s) in " << fn2 << ":\n  " << str2;
                no2 = sync(no1, if2, str2, np_cnt < 10); // skip tests in file 2
            }

            if(no1 < no2)   // extra test in file 1
            {
                cout << "\nextra test(s) in " << fn1 << ":\n  " << str1;
                no1 = sync(no2, if1, str1, np_cnt < 10);// skip tests in file 1
            }
        }
        else if(ty1 != ty2) // cannot synchronise test vector files
        {
            cout << "\n*** synchronisation error tests " << no1
                    << " and " << no2 << " ***";

            cout.flush(); return;
        }
        else if(ty1 != bad_line)   // test vector mismatch
        {
            err_cnt++;

            cout << "\r*** mismatch error test " << no1 << " ***";
        }

        cout.flush();
    }

    if(np_cnt && !err_cnt)  // all tests present match

        cout << "\nother tests match\n";

    else
    {
        if(err_cnt)
        {
            cout << '\r' << fn1 << " doesn't match " << fn2 
                                            << " (" << err_cnt << "errors)\n"; 
        }
        else
        {
            cout << '\r' << fn1 << " matches " << fn2 << '\n';
        }
    }

    std::cout.flush();
    if1.close(); if2.close();
}

// array of functions to call for each test

typedef void (*f_ep)(ofstream& outf, f_ctx* alg, const word blen, const word klen);
typedef void (*f_dp)(ofstream& outf, f_ctx* alg, const word blen, const word klen);

f_ep f_ptr[8] = { ecb_vk, ecb_vt, ecb_vkn, ecb_vtn, ecb_me, (f_ep)ecb_md, cbc_me, (f_ep)cbc_md };

// do the tests for each algorithm

void do_tests(bool do_cmp, bool ttype[3], f_ctx* alg, const word blen, const word klen)
{   char       name1[128], name2[128], *sp1, *sp2;
    int        i;
    ofstream   outf;

    cout << "\nGenerate" << (do_cmp ? " and verify" : "") 
         << " tests for aes (block_size = " << 8 * blen 
         << ", key size = " << 8 * klen << ")\n";

    for(i = 0; i < 8; ++i)  // for each type of test /k /x /e /c (2 tests each)
        if(ttype[i / 2])    // if this test required
        {
            // name of file for output of generated test vectors

            sp1 = copy_str(name1, out_path);
            sp2 = copy_str(name2, ref_path);
            file_name(sp1, i, blen, klen);
            copy_str(sp2, sp1);

            outf.open(name1, ios::out);

            if(outf)      // if output file is open write it
            {
                header(outf, i, blen, klen);
                f_ptr[i](outf, alg, blen, klen);
                outf << '\n'; outf.close();

                if(do_cmp)  // compare it with reference if required
                    comp_vecs(name2, name1);
            }
       }
}

#ifdef  AES_DLL

#include "windows.h"

HINSTANCE init_dll(fn_ptrs& fn)
{   HINSTANCE   h_dll;

    if(!(h_dll = LoadLibrary(dll_path)))
    {
        std::cout << "\n\nDynamic link Library AES_DLL not found\n\n"; return 0;
    }

    fn.fn_blk_len = (g_blk_len*)GetProcAddress(h_dll, "_aes_blk_len@8");
    fn.fn_enc_key = (g_enc_key*)GetProcAddress(h_dll, "_aes_enc_key@12");
    fn.fn_dec_key = (g_dec_key*)GetProcAddress(h_dll, "_aes_dec_key@12");
    fn.fn_enc_blk = (g_enc_blk*)GetProcAddress(h_dll, "_aes_enc_blk@12");
    fn.fn_dec_blk = (g_dec_blk*)GetProcAddress(h_dll, "_aes_dec_blk@12");

#if !defined(BLOCK_SIZE)
    if(!fn.fn_enc_key || !fn.fn_dec_key || !fn.fn_enc_blk  || !fn.fn_dec_blk || !fn.fn_blk_len)
#else
    if(!fn.fn_enc_key || !fn.fn_dec_key || !fn.fn_enc_blk  || !fn.fn_dec_blk)
#endif
    {
        std::cout << "\n\nRequired DLL Entry Point(s) not found\n\n"; 
        FreeLibrary(h_dll); 
        return 0;
    }

    return h_dll;
}

#endif  // AES_DLL

int main(int argc, char *argv[])
{   bool    do_cmp, tyf[4], bf[5], kf[5];
    f_ctx   alg;

#if defined(AES_DLL)
    HINSTANCE   h_dll;

    if(!(h_dll = init_dll(fn))) return -1;
#endif

#if !defined(AES_IN_CPP)
    alg.n_blk = 0;
    alg.n_rnd = 0;
#endif

    if(argc == 1)
    {
        cout << "\nusage: aes_gav /t:[knec] /b:[45678] /k:[45678] [/c]";
        cout << "\n";
        cout << "\nwhere the symbols in square brackets can be used in";
        cout << "\nany combination (without the brackets) and have the";
        cout << "\nfollowing meanings:";
        cout << "\n";
        cout << "\n        /t:[knec]   selects which tests are used";
        cout << "\n        /b:[45678]  selects the block lengths used";
        cout << "\n        /k:[45678]  selects the key lengths used";
        cout << "\n        /c          compares output with reference";
        cout << "\nwhere:";
        cout << "\n        k: generate ECB Known Answer Test files";
        cout << "\n        n: generate ECB Known Answer Test files (new)";
        cout << "\n        e: generate ECB Monte Carlo Test files";
        cout << "\n        c: generate CBC Monte Carlo Test files";
        cout << "\n";
        cout << "\nand the characters giving block and key lengths are";
        cout << "\ndigits representing the lengths in 32-bit units.\n\n";
        exit(0);
    }

    cout << "\nRun tests for the AES algorithm"

#if defined(AES_DLL)
    " (DLL Version)\n";
#else
    "\n";
#endif

    do_cmp = test_args(argc, argv, 'c', '\0');

    tyf[0] = test_args(argc, argv, 't', 'k');
    tyf[1] = test_args(argc, argv, 't', 'n');
    tyf[2] = test_args(argc, argv, 't', 'e');
    tyf[3] = test_args(argc, argv, 't', 'c');

    kf[0] = test_args(argc, argv, 'k', '4');
    kf[1] = test_args(argc, argv, 'k', '5');
    kf[2] = test_args(argc, argv, 'k', '6');
    kf[3] = test_args(argc, argv, 'k', '7');
    kf[4] = test_args(argc, argv, 'k', '8');

    if(!(kf[0] || kf[1] || kf[2] || kf[3] || kf[4]))
    {
        kf[0] = kf[2] = kf[4] = true;   // AES key sizes if not specified
        kf[1] = kf[3] = false;
    }

#if !defined(BLOCK_SIZE)
    bf[0] = test_args(argc, argv, 'b', '4');
    bf[1] = test_args(argc, argv, 'b', '5');
    bf[2] = test_args(argc, argv, 'b', '6');
    bf[3] = test_args(argc, argv, 'b', '7');
    bf[4] = test_args(argc, argv, 'b', '8');

    if(!(bf[0] || bf[1] || bf[2] || bf[3] || bf[4]))
    {
        bf[0] = true;                   // AES block size if not specified
        bf[1] = bf[2] = bf[3] = bf[4] = false;
    }
#else
    bf[0] = bf[1] = bf[2] = bf[3] = bf[4] = false;
    bf[(BLOCK_SIZE - 16) / 4] = true;
#endif

    for( int bi = 0; bi < 5; ++bi) if(bf[bi])
    {
#if defined(AES_DLL)
            if(fn.fn_blk_len) f_blk_len(&alg, 16 + 4 * bi);
#elif !defined(BLOCK_SIZE)
            f_blk_len(&alg, 16 + 4 * bi);
#else
            if(16 + 4 * bi != BLOCK_SIZE) continue;
#endif
        for(int ki = 0; ki < 5; ++ki) if(kf[ki])
        {
            do_tests(do_cmp, tyf, &alg, 16 + 4 * bi, 16 + 4 * ki);
        }
    }

#if defined(AES_DLL)
    if(h_dll) FreeLibrary(h_dll);
#endif

    cout << "\n\n";
    return 0;
}