using Nemerle.IO;

module M {
  Main () : void
  {
    if (System.Int32.MaxValue > System.Int32.MinValue) {} else printf ("oops Int32\n");
    def bval = System.Int32.MaxValue > System.Int32.MinValue;
    assert (bval);

    if (System.Int16.MaxValue > System.Int16.MinValue) {} else printf ("oops Int16\n");
    def bval = System.Int16.MaxValue > System.Int16.MinValue;
    assert (bval);

    if (System.Int64.MaxValue > System.Int64.MinValue) {} else printf ("oops Int64\n");
    def bval = System.Int64.MaxValue > System.Int64.MinValue;
    assert (bval);

    if (System.UInt32.MaxValue > System.UInt32.MinValue) {} else printf ("oops UInt32\n");
    def bval = System.UInt32.MaxValue > System.UInt32.MinValue;
    assert (bval);

    if (System.UInt16.MaxValue > System.UInt16.MinValue) {} else printf ("oops UInt16\n");
    def bval = System.UInt16.MaxValue > System.UInt16.MinValue;
    assert (bval);

    if (System.UInt64.MaxValue > System.UInt64.MinValue) {} else printf ("oops UInt64\n");
    def bval = System.UInt64.MaxValue > System.UInt64.MinValue;
    assert (bval);

    if (System.SByte.MaxValue > System.SByte.MinValue) {} else printf ("oops SByte\n");
    def bval = System.SByte.MaxValue > System.SByte.MinValue;
    assert (bval);

    if (System.Byte.MaxValue > System.Byte.MinValue) {} else printf ("oops Byte\n");
    def bval = System.Byte.MaxValue > System.Byte.MinValue;
    assert (bval);



    if (System.Int32.MaxValue >= System.Int32.MinValue) {} else printf ("oops Int32\n");
    def bval = System.Int32.MaxValue >= System.Int32.MinValue;
    assert (bval);

    if (System.Int16.MaxValue >= System.Int16.MinValue) {} else printf ("oops Int16\n");
    def bval = System.Int16.MaxValue >= System.Int16.MinValue;
    assert (bval);

    if (System.Int64.MaxValue >= System.Int64.MinValue) {} else printf ("oops Int64\n");
    def bval = System.Int64.MaxValue >= System.Int64.MinValue;
    assert (bval);

    if (System.UInt32.MaxValue >= System.UInt32.MinValue) {} else printf ("oops UInt32\n");
    def bval = System.UInt32.MaxValue >= System.UInt32.MinValue;
    assert (bval);

    if (System.UInt16.MaxValue >= System.UInt16.MinValue) {} else printf ("oops UInt16\n");
    def bval = System.UInt16.MaxValue >= System.UInt16.MinValue;
    assert (bval);

    if (System.UInt64.MaxValue >= System.UInt64.MinValue) {} else printf ("oops UInt64\n");
    def bval = System.UInt64.MaxValue >= System.UInt64.MinValue;
    assert (bval);

    if (System.SByte.MaxValue >= System.SByte.MinValue) {} else printf ("oops SByte\n");
    def bval = System.SByte.MaxValue >= System.SByte.MinValue;
    assert (bval);

    if (System.Byte.MaxValue >= System.Byte.MinValue) {} else printf ("oops Byte\n");
    def bval = System.Byte.MaxValue >= System.Byte.MinValue;
    assert (bval);



    if (System.Int32.MinValue < System.Int32.MaxValue) {} else printf ("oops Int32\n");
    def bval = System.Int32.MinValue < System.Int32.MaxValue;
    assert (bval);

    if (System.Int16.MinValue < System.Int16.MaxValue) {} else printf ("oops Int16\n");
    def bval = System.Int16.MinValue < System.Int16.MaxValue;
    assert (bval);

    if (System.Int64.MinValue < System.Int64.MaxValue) {} else printf ("oops Int64\n");
    def bval = System.Int64.MinValue < System.Int64.MaxValue;
    assert (bval);

    if (System.UInt32.MinValue < System.UInt32.MaxValue) {} else printf ("oops UInt32\n");
    def bval = System.UInt32.MinValue < System.UInt32.MaxValue;
    assert (bval);

    if (System.UInt16.MinValue < System.UInt16.MaxValue) {} else printf ("oops UInt16\n");
    def bval = System.UInt16.MinValue < System.UInt16.MaxValue;
    assert (bval);

    if (System.UInt64.MinValue < System.UInt64.MaxValue) {} else printf ("oops UInt64\n");
    def bval = System.UInt64.MinValue < System.UInt64.MaxValue;
    assert (bval);

    if (System.SByte.MinValue < System.SByte.MaxValue) {} else printf ("oops SByte\n");
    def bval = System.SByte.MinValue < System.SByte.MaxValue;
    assert (bval);

    if (System.Byte.MinValue < System.Byte.MaxValue) {} else printf ("oops Byte\n");
    def bval = System.Byte.MinValue < System.Byte.MaxValue;
    assert (bval);



    if (System.Int32.MinValue <= System.Int32.MaxValue) {} else printf ("oops Int32\n");
    def bval = System.Int32.MinValue <= System.Int32.MaxValue;
    assert (bval);

    if (System.Int16.MinValue <= System.Int16.MaxValue) {} else printf ("oops Int16\n");
    def bval = System.Int16.MinValue <= System.Int16.MaxValue;
    assert (bval);

    if (System.Int64.MinValue <= System.Int64.MaxValue) {} else printf ("oops Int64\n");
    def bval = System.Int64.MinValue <= System.Int64.MaxValue;
    assert (bval);

    if (System.UInt32.MinValue <= System.UInt32.MaxValue) {} else printf ("oops UInt32\n");
    def bval = System.UInt32.MinValue <= System.UInt32.MaxValue;
    assert (bval);

    if (System.UInt16.MinValue <= System.UInt16.MaxValue) {} else printf ("oops UInt16\n");
    def bval = System.UInt16.MinValue <= System.UInt16.MaxValue;
    assert (bval);

    if (System.UInt64.MinValue <= System.UInt64.MaxValue) {} else printf ("oops UInt64\n");
    def bval = System.UInt64.MinValue <= System.UInt64.MaxValue;
    assert (bval);

    if (System.SByte.MinValue <= System.SByte.MaxValue) {} else printf ("oops SByte\n");
    def bval = System.SByte.MinValue <= System.SByte.MaxValue;
    assert (bval);

    if (System.Byte.MinValue <= System.Byte.MaxValue) {} else printf ("oops Byte\n");
    def bval = System.Byte.MinValue <= System.Byte.MaxValue;
    assert (bval);


    printf ("ok\n");

    def x = -1;
    def y = -1s;
    def z = -1l;
    print ("$x $y $z\n");

    printf ("%d\n", 1 << 5);
    printf ("%d\n", (1 << 5) >> 5);
  }
}

/*
BEGIN-OUTPUT
ok
-1 -1 -1
32
1
END-OUTPUT
*/