import core.stdc.stdarg;
 
void test()
{
    foo(3, 4, 5);   // first variadic argument is 5
}
 
int foo(int x, int y, ...)
{
    va_list ap;
 
    version (X86)
        va_start(args, y);  // y is the last named parameter
    else
    version (Win64)
        va_start(args, y);  // ditto
    else
    version (X86_64)
        va_start(args, __va_argsave);
    else
    static assert(0, "Platform not supported.");
 
    int z;
    va_arg(ap, z);  // z is set to 5
}

import std.stdio;
 
enum N = 15;
enum int[] factorials = memoizeFactorials(N);
 
int[] memoizeFactorials(int n)
{
    if (!__ctfe) {
        // Make sure that this function is never called at run time
        assert(false);
    }
    
    int[] result = new int[n];
    
    result[0] = 1;
    
    foreach (i; 1 .. n) {
        result[i] = result[i - 1] * i;
    }
    
    return result;
}
 
int fact(int n)
{
    return factorials[n];
}
 
void main()
{
    foreach (i; 0 .. N) {
        writeln(fact(i));
    }
}

import std.stdio;
 
enum N = 15;
enum int[] factorials = memoizeFactorials(N);
 
int[] memoizeFactorials(int n)
{
    if (!__ctfe) {
        // Make sure that this function is never called at run time
        assert(false);
    }
    
    int[] result = new int[n];
    
    result[0] = 1;
    
    foreach (i; 1 .. n) {
        result[i] = result[i - 1] * i;
    }
 
    return result;
}
 
int fact(int n)
{
    return factorials[n];
}
 
void main()
{
    writeln("Enter a key: ");
    string key;
    readf(" %s\n", &key);
    if (key == "Yes")
        foreach (i; 0 .. N)
            writeln(fact(i));
    else
        writeln("No");
}

import std.stdio, std.functional;
 
enum N = 15;
static int[] factorials = memoizeFactorials(N);
 
int[] memoizeFactorials(int n)
{
    if (!__ctfe) {
        // Make sure that this function is never called at run time
        assert(false);
    }
    
    int[] result = new int[n];
    
    result[0] = 1;
    
    foreach (i; 1 .. n) {
        result[i] = result[i - 1] * i;
    }
 
    return result;
}
 
int fact(int n)
{
    return factorials[n];
}
 
ulong factm(ulong n)
{
    alias mfact = memoize!factm;
    return n < 2 ? 1 : n * mfact(n - 1);
}
 
void main()
{
    string key;
 
    writeln("Please enter how you want to count the fucking memoized factorial: auto or static?");
 
    readf(" %s\n", &key);
 
    if (key == "auto")
        foreach (i; 0 .. N) {
            assert(factorials.ptr + i == &(factorials[i]));
        }
    else
        assert(factm(10) == 3628800);
}