#include <stdint.h>

template<class X>
struct Foo
{
    X *v;
};

template<class X>
struct Boo
{
    X *v;
};

void test1(Foo<int> arg1)
{
}


void test2(int* arg2, Boo<int*> arg1)
{
}

template<int X, int Y>
struct Test3
{

};

void test3(Test3<3,3> arg1)
{
}

void test4(Foo<int*> arg1, Boo<int*> arg2, Boo<int*> arg3, int*, Foo<double>)
{
}

void test5(Foo<int*> arg1, Boo<int*> arg2, Boo<int*> arg3)
{
}

struct Goo
{

    template<class X>
    struct Foo
    {
        X* v;
    };

    template<class X>
    struct Boo
    {
        template<class Y>
        struct Xoo
        {
            Y* v;
        };
        X* v;
    };


    void test6(Foo<Boo<Foo<void> > > arg1);
    void test7(Boo<void>::Xoo<int> arg1);
};

void Goo::test6(Goo::Foo<Goo::Boo<Goo::Foo<void> > > arg1)
{
}

void Goo::test7(Goo::Boo<void>::Xoo<int> arg1)
{
}

struct P1
{
    template<class T>
    struct Mem
    {
    };
};

struct P2
{
    template<class T>
    struct Mem
    {
    };
};

void test8(P1::Mem<int>, P2::Mem<int>){}
void test9(Foo<int**>, Foo<int*>, int**, int*){}


class Test10
{
    private: void test10();
    public: void test11();
    protected: void test12();
    public: void test13() const;

    private: void test14(); // Private methods in D are always non-virtual
    public: virtual void test15();
    protected: virtual void test16();

    private: static void test17();
    public: static void test18();
    protected: static void test19();
};

Test10* Test10Ctor()
{
    return new Test10();
}

void Test10Dtor(Test10*& ptr)
{
    delete ptr;
    ptr = 0;
}

void Test10::test10(){}
void Test10::test11(){}
void Test10::test12(){}
void Test10::test13() const{}
void Test10::test14(){}
void Test10::test15(){}
void Test10::test16(){}
void Test10::test17(){}
void Test10::test18(){}
void Test10::test19(){}

struct Test20
{
    private: static int test20;
    protected: static int test21;
    public: static int test22;
};

int Test20::test20 = 20;
int Test20::test21 = 21;
int Test20::test22 = 22;

int test23(Test10**, Test10*, Test10***, Test10 const *const)
{
    return 1;
}

int test23b(Test10 const *const *const,  Test10 const* const, Test10*)
{
    return 1;
}

void test24(int(*)(int,int))
{
}

void test25(int arr[2][5][6][291])
{
}

int test26(int arr[5][6][291])
{
    return arr[1][1][1];
}

void test27(int, ...){}
void test28(int){}

void test29(float){}
void test30(const float){}

template<class T>
struct Array
{
    int dim;
};

class Module
{
public:
    static void imports(Module*);
    static int dim(Array<Module*>*);
};


void Module::imports(Module*)
{
}

int Module::dim(Array<Module*>* arr)
{
    return arr->dim;
}

#if _LP64
unsigned long testlongmangle(int32_t a, uint32_t b, long c, unsigned long d)
{
    return a + b + c + d;
}
#else
unsigned long long testlongmangle(int a, unsigned int b, long long c, unsigned long long d)
{
    return a + b + c + d;
}
#endif

int test31[2][2][2] = {1, 1, 1, 1, 1, 1, 1, 1};
int *test32 = 0;


class Expression;

typedef int (*apply_fp_t)(Expression*, void*);

class Expression
{
    int type;
public:
    int apply(apply_fp_t fp, apply_fp_t fp2, void *param);
    int getType();
    static Expression* create(int v);
    static void dispose(Expression*&);
};

int Expression::apply(apply_fp_t fp, apply_fp_t fp2, void *param)
{
    return fp(this, param) * fp2(this, param);
}

int Expression::getType()
{
    return type;
}

Expression* Expression::create(int v)
{
    Expression *e = new Expression();
    e->type = v;
    return e;
}

void Expression::dispose(Expression *&e)
{
    if (e)
        delete e;
    e = 0;
}

/*int test34(int v[0][0][0])
{
    return 0;
}*/

#ifndef _MSC_VER
    int test35(long double arg)
    {
        return (int)arg;
    }
#endif

const char *test36(const char *arg)
{
    return arg;
}

class Test37
{
public:
    static Test37 *create();
    bool test();
};

bool test37()
{
    Test37 *o = Test37::create();
    return o->test();
}

class Test38
{
public:
     int test(int, ...);
     static Test38* create();
     static void dispose(Test38*&);
};

int Test38::test(int a, ...)
{
    return a;
}

Test38* Test38::create()
{
    Test38 *t = new Test38();
    return t;
}

void Test38::dispose(Test38 *&t)
{
    if (t)
        delete t;
    t = 0;
}

class S1
{
    int val;
public:
    static S1* init(int);
    S1(int v) : val(v) {}
    int value();
};

S1* S1::init(int x)
{
    return new S1(x);
}

int S1::value()
{
    return val;
}

template<class T>
class S2
{
    T val;
public:
    static S2<T>* init(T);
    S2(T v) : val(v) {}
    T value();
};

template<>
S2<int>* S2<int>::init(int x)
{
    return new S2<int>(x);
}

template<>
int S2<int>::value()
{
    return val;
}

struct C1
{
    const char *data;

    static C1* init(const char *p);

    C1(const char* p) : data(p) { }

    virtual const char* getDataCPP();
    virtual const char* getDataD();
};

C1* C1::init(const char *p)
{
    return new C1(p);
}

const char* C1::getDataCPP()
{
    return data;
}

template<class T>
struct C2
{
    const T *data;

    static C2* init(const T *p);

    C2(const T* p) : data(p) { }

    virtual const T* getData();
};

template<>
C2<char>* C2<char>::init(const char *p)
{
    return new C2<char>(p);
}

template<>
const char* C2<char>::getData()
{
    return data;
}

int test39cpp(C2<char>* c2, S2<int>* s2)
{
    C2<char>* otherC2 = C2<char>::init(c2->getData());
    if (c2->getData() != otherC2->getData())
        return 1;
    S2<int>* otherS2 = S2<int>::init(s2->value());
    if (s2->value() != otherS2->value())
        return 2;
    return 0;
}