// RUNNABLE_PHOBOS_TEST
// REQUIRED_ARGS:

module test;

import core.vararg;
import core.stdc.stdlib;
import std.stdio;
import std.string;
import core.stdc.stdlib;


/*******************************************/

struct S
{
    int opSliceAssign(int v, size_t i, size_t j)
    {
        assert(v == 5);
        assert(i == 9);
        assert(j == 10);
        return 3;
    }

    int opSliceAssign(int v)
    {
        assert(v == 6);
        return 11;
    }
}

void test1()
{
    S s;

    assert((s[9 .. 10] = 5) == 3);
    assert((s[] = 6) == 11);
}

/*******************************************/

static int i2 = 1;

void test2()
{
    synchronized { int i2 = 2; }
    assert(i2 == 1);
}

/*******************************************/

void test3()
{
    size_t border = 8;

    for(ulong i = 0; i < border; i++)
    {
        ulong test = 1;
        test <<= i;
        double r = test;
        ulong result = cast(ulong)r;

        if (result != test)
        {
            assert(0);
        }
    }
}

/*******************************************/

void test4()
{
    writeln("",true);
}

/*******************************************/

void test5()
{
    int[] qwert = new int[6];
    int[] yuiop;
    yuiop = qwert[2..5] = 3;
    assert(yuiop.length == 3);
    assert(yuiop[0] == 3);
    assert(yuiop[1] == 3);
    assert(yuiop[2] == 3);
}

/*******************************************/

struct Foo6
{
    static int x;

    static int[] farray()
    {
        printf("farray\n");
        assert(x == 0);
        x++;
        return new int[6];
    }

    static int flwr()
    {
        printf("flwr\n");
        assert(x == 1);
        x++;
        return 2;
    }

    static int fupr()
    {
        printf("fupr\n");
        assert(x == 2);
        x++;
        return 1;
    }
}

void test6()
{
    int[] yuiop;
    yuiop =
        Foo6.farray()[Foo6.flwr() .. $ - Foo6.fupr()] = 3;
    assert(Foo6.x == 3);
    assert(yuiop.length == 3);
    assert(yuiop[0] == 3);
    assert(yuiop[1] == 3);
    assert(yuiop[2] == 3);
}

/*******************************************/

void test7()
{
    real a = 3.40483; // this is treated as 3.40483L
    real b;
    b = 3.40483;
    assert(a==b);
    assert(a==3.40483);
    assert(a==3.40483L);
    assert(a==3.40483F);
}

/*******************************************/

void test8()
{
   real [5][5] m = 1;
   m[1][1..3] = 2;

   for (size_t i = 0; i < 5; i++)
        for (size_t j = 0; j < 5; j++)
        {
            if (i == 1 && (j >= 1 && j < 3))
                assert(m[i][j] == 2);
            else
                assert(m[i][j] == 1);
        }
}

/*******************************************/

class ClassOf(Type)
{
    Type val;

    template refx()
    {
        alias val refx;
    }
}

struct StructOf
{
    int val;

    template refx()
    {
        alias val refx;
    }
}

void test9()
{
    ClassOf!(int)  c = new ClassOf!(int)();
    StructOf s;
    int x = 10;

    c.refx!() = x;
    x = c.refx!();
    assert(x == 10);

    x = 11;
    s.refx!() = x;
    x = s.refx!();
    assert(x == 11);
}


/*******************************************/

void test10()
{
    static if( int.mangleof.length > 1 && int.mangleof[1] == 'x' )
        printf("'x' as second char\n");
}

/*******************************************/

class Foo11 : Bar11 { }

class Foo11T(V)
{
    public void foo() {}
}

class Bar11
{
    public this(){
        f = new Foo11T!(int);
    }
    Foo11T!(int) f;
}

void test11()
{
    Foo11 fooIt = new Foo11();
    if (fooIt !is null)
        writefln("fooIt should be valid");
    fooIt.f.foo();
    writefln("it worked");
}

/*******************************************/

struct A12 {
        int a;
        union {
                int c;
                B12 b;
        }
}

struct B12 {
        int b1;
        int b2;
}

void test12()
{
        A12 a;
        printf("%d\n", A12.sizeof);
        assert(A12.sizeof == 12);
}

/*******************************************/

template declare13(X) { X declare13; }

typeof(declare13!(int[0]).ptr[0]) x13;
typeof(declare13!(typeof(""))[0..$]) y13;

void test13()
{
}

/*******************************************/

interface Father {}

class Mother {
     Father test() {
         writefln("Called Mother.test!");
         return new Child(42);
     }
}

class Child : Mother, Father {
     int data;

     this(int d) { data = d; }

     override Child test() {
         writefln("Called Child.test!");
         return new Child(69);
     }
}

void test14()
{
     Child aChild = new Child(105);
     Mother childsMum = aChild;
     Child childsChild = aChild.test();
     Child mumsChild = cast(Child) childsMum.test();
     writefln("Success2");
}


/*******************************************/

class A15
{
        int a = 3;

        class B
        {
            void bar()
            {
                assert(a == 3);
            }
        }

        void fork()
        {
                assert(a == 3);
                B b = new B();  // This is okay
                b.bar();

                void knife()
                {
                        assert(a == 3);
                        B b = new B();  // No 'this' for nested class B
                        b.bar();
                }
        }
}

void test15()
{
    A15 a = new A15();
    a.fork();
}

/*******************************************/

creal x16;

void foo16()
{
        x16 = -x16;
}

void bar16()
{
        return foo16();
}

void test16()
{
        x16 = 2.0L + 0.0Li;
        bar16();
        assert(x16 == -2.0L + 0.0Li);
}

/*******************************************/

void test17()
{
    version(D_InlineAsm_X86_64)
        enum AsmX86 = true;
    else version(D_InlineAsm_X86)
        enum AsmX86 = true;
    else
        enum AsmX86 = false;

    version (OSX)
    {
    }
    else
    {
        const f = 1.2f;
        float g = void;

        static if (AsmX86)
        {
            asm
            {
                fld f;  // doesn't work with PIC
                fstp g;
            }
        }
        else
        {
            g = f;
        }
        assert(g == 1.2f);
    }
}

/*******************************************/

class Foo18 : Bar18 {}
class FooT18(V){}
class Bar18 : FooT18!(int) {}

void test18()
{
}

/*******************************************/

struct STRUCTA19
{
  union {
    int a;
    long b;
  }
  STRUCTB19 c;
}

struct STRUCTB19
{
  int a;
}

void test19()
{
}

/*******************************************/

class Foo20
{
        void bar (void * src)
        {
                void baz (void function (void *, size_t) xyz)
                {
                        size_t foo (void [] dst)
                        {
                                size_t len = dst.length;
                                dst [0 .. len] = src [0 .. len];
                                xyz (dst.ptr, len);
                                return len;
                        }
                }
        }
}

void test20()
{
}

/*******************************************/

class Baz21
{
        int opApply (int delegate(ref int) dg)
        {
                int i;
                return dg(i);
        }
}

class Foo21
{
        Baz21    baz;

        int foo (int delegate() dg)
        {
                foreach (b; baz)
                         if (bar ())
                            if (dg ())
                                break;
                return 0;
        }

        bool bar ()
        { return true; }
}

void test21()
{
}

/*******************************************/

struct Bar22 {
    union {
        struct {
            union {
                Foo22 A;
            }
        }
    }
}

struct Foo22 {
    double d = 3;
}

void test22()
{
    printf("Bar22.sizeof = %zd, double.sizeof = %zd\n", Bar22.sizeof, double.sizeof);
    assert(Bar22.sizeof == double.sizeof);
    Bar22 b;
    assert(b.A.d == 3);
}

/*******************************************/

struct Ag
{
    static void func(){}

    static void foo()
    {
        void function() fnp;
        Ag a;

        fnp = &func;
        fnp = &Ag.func;
        with(a)    fnp = &Ag.func;

        with(a) fnp = &func;
    }
}

class Ah
{
    static void func(){}

    static void foo()
    {
        void function() fnp;
        Ah a;

        fnp = &func;
        fnp = &Ah.func;
        with(a)    fnp = &Ah.func;

        with(a) fnp = &func;
    }
}

void test23()
{
}

/*******************************************/

void test24()
{
    uint[10] arr1;
    ulong idx = 3;
    uint[] arr3 = arr1[ cast(int)(idx) .. (cast(int) idx) + 3  ]; // OK
    uint[] arr4 = arr1[ cast(int) idx  ..  cast(int) idx  + 3  ]; // OK
    uint[] arr5 = arr1[ cast(int)(idx) ..  cast(int)(idx) + 3  ]; // C style cast illegal, use cast(idx)+3
    uint[] arr6 = arr1[ cast(int)(idx) ..  cast(int)(idx  + 3) ]; // OK
}

/*******************************************/

void test25()
{
    char[6] cstr = "123456"c;
    auto str1 = cast(wchar[3])(cstr);

    writefln("str1: ", (cast(char[])str1).length , " : ", (cast(char[])str1));
    assert(cast(char[])str1 == "123456"c);

    auto str2 = cast(wchar[3])("789abc"c);
    writefln("str2: ", (cast(char[])str2).length , " : ", (cast(char[])str2));
    assert(cast(char[])str2 == "789abc"c);

    auto str3 = cast(wchar[3])("defghi");
    writefln("str3: ", (cast(char[])str3).length , " : ", (cast(char[])str3));
    version (LittleEndian)
        assert(cast(char[])str3 == "d\000e\000f\000"c);
    version (BigEndian)
        assert(cast(char[])str3 == "\000d\000e\000f"c);
}

/*******************************************/

void test26()
{
    assert(foo26(5) == 25);
}

int foo26(int i)
{
    if (auto j = i * i)
      return j;
    else
      return 10;
}

/*******************************************/

class A27
{
    int am;

    class B
    {
        this()
        {
            assert(am == 3);
        }
    }

    void fork()
    {
        B b = new B();  // This is okay

        void knife()
        {
                B b = new B();  // No 'this' for nested class B
                assert(am == 3);
        }
    }
}


void test27()
{
    A27 a = new A27();
    a.am = 3;

    a.fork();
}

/*******************************************/

uint intRes()
{
        return 4;
}

void test28()
{
        auto s = std.string.format("%s", "abc123"[intRes() % $] );
        writefln( "%s", s );
        assert(s == "2");

        static const char[] foo = "abc123";
        s = std.string.format("%s", foo[intRes() % $] );
        assert(s == "2");


        static string bar = "abc123";
        s = std.string.format("%s", bar[intRes() % $] );
        assert(s == "2");

        const char[] abc = "abc123";
        s = std.string.format("%s", abc[intRes() % $] );
        assert(s == "2");

        string def = "abc123";
        s = std.string.format("%s", def[intRes() % $] );
        assert(s == "2");
}

/*******************************************/

class UA {
    A29 f() { return null; }
}

class UB : UA {
    override B29 f() { return null; }
}

class A29
{
}

class B29 : A29
{
}

void test29()
{
}

/*******************************************/

class Foo30 : Bar30 {}

class FooT30(V) {}

class Bar30 : FooT30!(int) {}

void test30()
{
}


/*******************************************/

int y31;

struct X31 { static void opCall() { y31 = 3; } }

void test31()
{
    X31 x;
    typeof(x)();
    assert(y31 == 3);
}

/*******************************************/

class Foo32
{
    static void* ps;

    new (size_t sz)
    {
        void* p = core.stdc.stdlib.malloc(sz);
        printf("new(sz = %d) = %p\n", sz, p);
        ps = p;
        return p;
    }

    delete(void* p)
    {
        printf("delete(p = %p)\n", p);
        assert(p == ps);
        if (p) core.stdc.stdlib.free(p);
    }
}

void test32()
{
    Foo32 f = new Foo32;
    delete f;
}

/*******************************************/

class Foo33
{
//    this() { printf("this()\n"); }
//    ~this() { printf("~this()\n"); }

    static void* ps;
    static int del;

    new (size_t sz, int i)
    {
        void* p = core.stdc.stdlib.malloc(sz);
        printf("new(sz = %d) = %p\n", sz, p);
        ps = p;
        return p;
    }

    delete(void* p)
    {
        printf("delete(p = %p)\n", p);
        assert(p == ps);
        if (p) core.stdc.stdlib.free(p);
        del += 1;
    }
}

void foo33()
{
    scope Foo33 f = new(3) Foo33;
}

void test33()
{
    foo33();
    assert(Foo33.del == 1);
}

/*******************************************/

struct o_O { int a; }
union  O_O { int a; }
class  O_o { int a; }

struct Foo34
{
    int ok;
    o_O foo;
    O_O bar;
    O_o baz;
}

void test34()
{
    int o1 = Foo34.ok.offsetof;
    assert(o1 == 0);
    int o2 = Foo34.foo.offsetof;
    assert(o2 == 4);
    int o3 = Foo34.bar.offsetof;
    assert(o3 == 8);
    int o4 = Foo34.baz.offsetof;
    assert((o4 % (void*).sizeof) == 0);
    assert(o4 > o3);
}

/*******************************************/

class Foo37
{
    float[4] array = 1.0;
    int count = 10;
}

void test37()
{
    Foo37 f = new Foo37();

    writefln("Foo.array[0] = %s", f.array[0] );
    writefln("Foo.array[1] = %s", f.array[1] );
    writefln("Foo.array[2] = %s", f.array[2] );
    writefln("Foo.array[3] = %s", f.array[3] );
    writefln("Foo.count = %s", f.count );

    assert(f.array[0] == 1.0);
    assert(f.array[1] == 1.0);
    assert(f.array[2] == 1.0);
    assert(f.array[3] == 1.0);
    assert(f.count == 10);
}

/*******************************************/

void test38()
in
{
    static void checkParameters()
    {
        return;
    }

    checkParameters();
}
body
{
}

/*******************************************/

void delegate() foo39()
{
        return &(new class
        {

                int a;

                this() { a = 3; }

                void dg()
                {
                        writefln("delegate!");
                        assert(a == 3);
                }
        }).dg;
}

void test39()
{
    void delegate() dg = foo39();

    dg();
}

/*******************************************/

void test40()
{
    assert( typeid(int) == typeid(int) );
    assert( (typeid(int) != typeid(int)) == false );

    int x;

    bool b1 = (typeid(typeof(x)) != typeid(int));

    TypeInfo t1 = typeid(typeof(x));
    TypeInfo t2 = typeid(int);

    bool b2 = (t1 != t2);

    assert(b1 == b2);
}

/*******************************************/

int foo41(string s)
{
        short shift = cast(short)(s.length * 3);
        int answer;

        for (size_t i = 0; i < s.length; i++){
                answer = s[i] << shift;
        }

        return answer;
}

void test41()
{
        if(foo41("\u0001") != 8){
                assert(0);
        }
}

/*******************************************/

struct S42
{
        int i;

        static S42 foo(int x){
                S42 s;

                s.i = x;

                return s;
        }
}

void test42()
{
        S42[] s;

        s = s ~ S42.foo(6);
        s = s ~ S42.foo(1);

        if(s.length != 2){
                assert(0);
        }
        if(s[0].i != 6){
                assert(0);
        }
        if(s[1].i != 1){
                assert(0);
        }
}

/*******************************************/

struct S43
{
        int i,j;

        static S43 foo(int x){
                S43 s;

                s.i = x;

                return s;
        }
}

void test43()
{
        S43[] s;

        s = s ~ S43.foo(6);
        s = s ~ S43.foo(1);

        if(s.length != 2){
                assert(0);
        }
        if(s[0].i != 6){
                assert(0);
        }
        if(s[1].i != 1){
                assert(0);
        }
}

/*******************************************/

struct S44
{
        int i,j,k;

        static S44 foo(int x){
                S44 s;

                s.i = x;

                return s;
        }
}

void test44()
{
        S44[] s;

        s = s ~ S44.foo(6);
        s = s ~ S44.foo(1);

        if(s.length != 2){
                assert(0);
        }
        if(s[0].i != 6){
                assert(0);
        }
        if(s[1].i != 1){
                assert(0);
        }
}

/*******************************************/

void test45()
{
   char[] buffer = "abcdefghijklmnopqrstuvwxyz".dup;
   foreach(ref char c; buffer)
   {
       if('a' <= c && c <= 'z')
       {
           c -= cast(char)'a' - 'A'; // segfault here
       }
   }
   for(int i = 0; i < buffer.length; i++)
   {
       if('a' <= buffer[i] && buffer[i] <= 'z')
       {
           buffer[i] -= cast(char)'a' - 'A'; // segfault here
       }
   }
   writeln(buffer);
}

/*******************************************/

struct st46
{
    template t1()
    {
        template t2(int n2) { }
    }
}

alias st46.t1!().t2 a46;

void test46()
{
}

/*******************************************/

struct A47
{
    static int y;
    void opSliceAssign(int x)
    {
        printf("x = %d\n", x);
        y = x;
    }
    A47 d() { return this; }
}

void test47()
{
    A47 a;
    a[] = 3;
    printf("y = %d\n", a.y);
    a.d()[] = 5;
    printf("y = %d\n", a.y);
    assert(a.y == 5);
    a.d[] = 6;
    printf("y = %d\n", a.y);
    assert(a.y == 6);
}

/*******************************************/

static uint[] sarray48 = void;

void test48()
{
    static uint[] array = void;

    assert(sarray48 == null);
    assert(array == null);
}

/*******************************************/

int x = 2, y = 1;

void foo50(int z)
{
    static int t;
    t++;
    assert(t == z);
}

void test50()
{
    printf("test50()\n");
    int res = 0;
    for(int i = 0; i < 10; i++)
    {
        res = res + x - y;
        foo50(res);
    }
}

/*******************************************/

void test52()
{
    printf("test52()\n");
    char[] s;
    s = ['a', 'b', 'c'];
    assert(s == "abc");

    int[] x;
    x = [17, 18u, 29, 33];
    assert(x.length == 4);
    assert(x[0] == 17);
    assert(x[1] == 18);
    assert(x[2] == 29);
    assert(x[3] == 33);
    assert(x == [17, 18, 29, 33]);
}

/*******************************************/

void test54()
{
    printf("test54()\n");
    uint[500][] data;

    data.length = 1;
    assert(data.length == 1);
    foreach (ref foo; data)
    {
        assert(foo.length == 500);
        foreach (ref u; foo)
        {   //printf("u = %u\n", u);
            assert(u == 0);
            u = 23;
        }
    }
    foreach (ref foo; data)
    {
        assert(foo.length == 500);
        foreach (u; foo)
        {   assert(u == 23);
            auto v = u;
            v = 23;
        }
    }
}

/*******************************************/

class Base56
{
        private string myfoo;
        private string mybar;

        // Get/set properties that will be overridden.
        void foo(string s) { myfoo = s; }
        string foo() { return myfoo; }

        // Get/set properties that will not be overridden.
        void bar(string s) { mybar = s; }
        string bar() { return mybar; }
}

class Derived56: Base56
{
        alias Base56.foo foo; // Bring in Base56's foo getter.
        override void foo(string s) { super.foo = s; } // Override foo setter.
}

void test56()
{
        Derived56 d = new Derived56;
        with (d)
        {
                foo = "hi";
                d.foo = "hi";
                bar = "hi";
                assert(foo == "hi");
                assert(d.foo == "hi");
                assert(bar == "hi");
        }
}

/*******************************************/

bool[void[]] reg57;

void addToReg57(const(void)[] a, int b, bool v)
{
    if (!v)
        writefln("X");
    auto key = a~(cast(void*)&b)[0..4];
    reg57[cast(immutable(void)[])key] = v;
    writefln("OK");
}

void test57()
{
        addToReg57("test", 1024, true);
}

/*******************************************/

int bar58( string msg ){
    return 1;
}

int foo58( lazy string dg ){
    return bar58( dg() );
}

void test58()
{
    printf("test58()\n");
    try{
    }
    finally{
        foo58("");
    }
}

/*******************************************/

struct S59
{
    string toString()
    {
        return "foo";
    }
}

void test59()
{   S59 s;
    writefln("s = %s", s);

    string p;
    p = std.string.format("s = %s", s);
    assert(p == "s = foo");
}

/*******************************************/

void test60()
{
    int[2][] a;
    a = [ [-1,2], [3,4] ];
    assert(a[0][0] == -1);
    assert(a[0][1] == 2);
    assert(a[1][0] == 3);
    assert(a[1][1] == 4);

    int[][] b;
    b = [ [-1,2], [3,4] ];
    assert(b[0][0] == -1);
    assert(b[0][1] == 2);
    assert(b[1][0] == 3);
    assert(b[1][1] == 4);
}

/*******************************************/

void test61()
{
    int[][] f = [[1,2],[3,4]];
    assert(f[0][0] == 1);
    assert(f[0][1] == 2);
    assert(f[1][0] == 3);
    assert(f[1][1] == 4);
    writeln(f);
}

/*******************************************/

struct List62 {
        void get() {}
}
struct Array62 {
        interface Model {
                List62 list();
        }
        List62 list() {
                return model ? model.list() : List62.init;
        }
        void item() {
                list.get();
        }
        private Model model;
}

void test62()
{
}

/*******************************************/

void foo63(...)
{
}

void test63()
{
        int[] arr;
        arr = [1] ~ 2;

        // runtime crash, the length == 1
        printf("%d\n", arr.length);
        assert (arr.length == 2);
        assert(arr[0] == 1);
        assert(arr[1] == 2);

        arr = 2 ~ [1];
        assert(arr.length == 2);
        assert(arr[0] == 2);
        assert(arr[1] == 1);

        arr = [2, 3] ~ [1];
        assert(arr.length == 3);
        assert(arr[0] == 2);
        assert(arr[1] == 3);
        assert(arr[2] == 1);

        foo63([1] ~ 2, 2 ~ [1], [1,2] ~ [3,4,5]);
}

/*******************************************/

void test64()
{
    printf("test64()\n");
    int[] x = [1,2,3,4];
    int j = 4;

    foreach_reverse(v; x)
    {
        writeln(v);
        assert(j == v);
        j--;
    }
    assert(j == 0);

    j = 4;
    foreach_reverse(i, v; x)
    {
        writefln("[%s] = %s", i, v);
        assert(i + 1 == j);
        assert(j == v);
        j--;
    }
    assert(j == 0);
    printf("-test64()\n");
}

/*******************************************/

void test65()
{
    // Bugzilla Issue 407.
    int i = *cast(int*)cast(char[4])['0', '0', '0', '0']; // compiler seg-fault
    printf("i = %x\n", i);
}

/*******************************************/

void test66()
{
    int[]  ia;
    ia ~= 3;
    byte[] data = new byte[ia[0]];
    byte[] data2 = new byte[ cast(int)(ia[0])];
}

/*******************************************/

class C68
{
    static int value;
}

void test68()
{
    auto v1 = test.C68.value;
    auto v2 = C68.classinfo;
    auto v3 = test.C68.classinfo;
    assert(v2 == v3);
}

/*******************************************/

void test69()
{
    class Bug
    {
      char[12] str = "";
      uint t = 1;
    }

    class NoBug
    {
      uint t = 2;
      char[12] str = "";
    }

    class NoBug2
    {
      char[12] str;
      uint t = 3;
    }

    auto b = new Bug;
    auto n = new NoBug;
    auto n2 = new NoBug2;

    writefln("bug %d", b.t);
    assert(b.t == 1);
    writefln("nobug %d", n.t);
    assert(n.t == 2);
    writefln("nobug2 %d", n2.t);
    assert(n2.t == 3);
}

/*******************************************/

void test70()
{
    void foo(char[0] p)
    {
    }

    static const char[0] altsep;
    string s = std.string.format("test%spath", altsep);
    assert(s == "testpath");
    foo(altsep);
}

/*******************************************/


class C71
{
    static int cnt;
    this() { printf("C()\n"); cnt++; }
    ~this() { printf("~C()\n"); cnt--; }
}

class D71
{
    static int cnt;
    this() { printf("D()\n"); cnt++; }
    ~this() { printf("~D()\n"); cnt--; }
}

class E71
{
    static int cnt;
    this() { printf("E()\n"); cnt++; }
    ~this() { printf("~E()\n"); cnt--; }
}

void test71()
{
  {
    int i = 0;
    printf("start\n");
    scope D71 d = new D71();
    assert(D71.cnt == 1);
    for (scope E71 e = new E71(); i < 5; i++)
    {
        assert(D71.cnt == 1);
        assert(E71.cnt == 1);
        scope c = new C71();
        assert(C71.cnt == 1);
    }
    assert(C71.cnt == 0);
    assert(E71.cnt == 0);
    assert(D71.cnt == 1);
    printf("finish\n");
  }
  assert(D71.cnt == 0);
}

/*******************************************/

size_t getLength(int[] arr) { return arr.length; }

void test13237()
{
        int[] arr = [0];
        immutable size_t len = getLength(arr);

        arr.length--;

        assert(len == 1); // ok
        if (len) { auto l = len; }
        assert(len == 1); // len cannot be changed, but produces Assertion failure with "-O -inline"
}

/*******************************************/

void main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();
    test8();
    test9();
    test10();
    test11();
    test12();
    test13();
    test14();
    test15();
    test16();
    test17();
    test18();
    test19();
    test20();
    test21();
    test22();
    test23();
    test24();
    test25();
    test26();
    test27();
    test28();
    test29();
    test30();
    test31();
    test32();
    test33();
    test34();
    test37();
    test38();
    test39();
    test40();
    test41();
    test42();
    test43();
    test44();
    test45();
    test46();
    test47();
    test48();
    test50();
    test52();
    test54();
    test56();
    test57();
    test58();
    test59();
    test60();
    test61();
    test62();
    test63();
    test64();
    test65();
    test66();
    test68();
    test69();
    test70();
    test71();
    test13237();

    printf("Success\n");
}