// For now, we are reading the last number of the function name to see what the result should be.
// This should be replaced with real tests inside Storm, whenever we implement a proper test syntax.

// Int
Int iConst20() { 20; }
Int iConst21() { 21i; }
Int iAdd12() { 10i + 2i; }
Int iSub5() { 10i - 5i; }
Int iSubN5() { 5i - 10i; }
Int iMul8() { 2i * 4i; }
Int iMulN8() { (0i-2i) * 4i; }
Int iDiv8() { 16i / 2i; }
Int iMod8() { 18i % 10i; }
Int iInc10() { Int i = 5; i += 5i; i; }
Int iDec10() { Int i = 15; i -= 5i; i; }
Int iInc12() { Int i = 10; i++; ++i; }
Int iInc11() { Int i = 10; ++i; i++; }
Int iMulEq8() { Int i = 4; i *= 2; i; }
Int iDivEq8() { Int i = 16; i /= 2; i; }
Int iModEq5() { Int i = 15; i %= 10; i; }
Int iDec8() { Int i = 10; i--; --i; }
Int iDec9() { Int i = 10; --i; i--; }
Int iAssign10() { Int i = 10; Int j = 5; j = i; j; }
Bool iLessF() { 20i < 10i; }
Bool iLessT() { 20i < 21i; }
Bool iLessEqF() { 20i <= 19i; }
Bool iLessEqT() { 20i <= 20i; }
Bool iGreaterF() { 20i > 30i; }
Bool iGreaterT() { 20i > 10i; }
Bool iGreaterEqF() { 20i >= 21i; }
Bool iGreaterEqT() { 20i >= 20i; }
Bool iEqF() { 20i == 22i; }
Bool iEqT() { 20i == 20i; }
Bool iNeqF() { 20i != 20i; }
Bool iNeqT() { 20i != 22i; }
Int iDelta10() { 20i.delta(30i); }
Int iDelta11() { 20i.delta(9i); }
Int iDelta50() { 20i.delta(-30i); }
Int iDelta29() { (-20i).delta(9i); }
Int iMin10() { 10i.min(20i); }
Int iMin11() { 21i.min(11i); }
Int iMinN10() { (-10i).min(20i); }
Int iMinN9() { 10i.min(-9i); }
Int iMax20() { 10i.max(20i); }
Int iMax11() { 11i.max(9i); }
Int iMax23() { 23i.max(-20i); }
Int iMax22() { (-10i).max(22i); }
Int iNegN2() { -(2i); }

// Nat
Nat nConst21() { 21; }
Nat nConst22() { 22n; }
Nat nAdd22() { 20n + 2n; }
Nat nSub10() { 15n - 5n; }
Nat nMul10() { 2n * 5n; }
Nat nDiv6() { 12n / 2n; }
Nat nMod2() { 12n % 10n; }
Nat nInc1() { Nat i = 0; i += 1; i; }
Nat nDec1() { Nat i = 6; i -= 5; i; }
Nat nMulEq8() { Nat i = 4; i *= 2; i; }
Nat nDivEq8() { Nat i = 16; i /= 2; i; }
Nat nModEq5() { Nat i = 15; i %= 10; i; }
Nat nInc8() { Nat i = 6; i++; ++i; }
Nat nInc7() { Nat i = 6; ++i; i++; }
Nat nDec4() { Nat i = 6; i--; --i; }
Nat nDec5() { Nat i = 6; --i; i--; }
Nat nAssign12() { Nat i = 12; Nat j = 5; j = i; j; }
Bool nLessF() { 20n < 10n; }
Bool nLessT() { 20n < 21n; }
Bool nLessEqF() { 20n <= 19n; }
Bool nLessEqT() { 20n <= 20n; }
Bool nGreaterF() { 20n > 30n; }
Bool nGreaterT() { 20n > 10n; }
Bool nGreaterEqF() { 20n >= 21n; }
Bool nGreaterEqT() { 20n >= 20n; }
Bool nEqF() { 20n == 22n; }
Bool nEqT() { 20n == 20n; }
Bool nNeqF() { 20n != 20n; }
Bool nNeqT() { 20n != 22n; }
Nat nDelta10() { 20n.delta(30n); }
Nat nDelta11() { 20n.delta(9n); }
Nat nMin10() { 10n.min(20n); }
Nat nMin11() { 21n.min(11n); }
Nat nMax20() { 10n.max(20n); }
Nat nMax11() { 11n.max(9n); }
Nat nAnd12() { 13n & 0xFE_n; }
Nat nOr10() { 8n | 2n; }
Nat nXor9() { 10n ^ 3n; }
Nat nNeg65535() { ~0xFFFF0000_n; }
Nat nAndEq12() { Nat v = 13; v &= 0xFE_n; v; }
Nat nOrEq10() { Nat v = 2; v |= 10n; v; }
Nat nXorEq9() { Nat v = 10; v ^= 3n; v; }


// Byte
Byte bConst22() { 22; }
Byte bConst23() { 23b; }
Byte bAdd23() { 21b + 2b; }
Byte bSub11() { 15b - 4b; }
Byte bMul10() { 2b * 5b; }
Byte bDiv7() { 15b / 2b; }
Byte bDiv50() { 200b / 4b; }
Byte bDiv25() { Byte i = 200b; i /= 8b; i; }
Byte bMod5() { 15b % 10b; }
Byte bInc2() { Byte i = 0; i += 2; i; }
Byte bDec2() { Byte i = 6; i -= 4; i; }
Byte bMulEq8() { Byte i = 4; i *= 2; i; }
Byte bDivEq8() { Byte i = 16; i /= 2; i; }
Byte bModEq8() { Byte i = 18; i %= 10; i; }
Byte bInc18() { Byte i = 16; i++; ++i; }
Byte bInc17() { Byte i = 16; ++i; i++; }
Byte bDec14() { Byte i = 16; i--; --i; }
Byte bDec15() { Byte i = 16; --i; i--; }
Byte bAssign13() { Byte i = 13; Byte j = 5; j = i; j; }
Bool bLessF() { 20b < 10b; }
Bool bLessT() { 20b < 21b; }
Bool bLessEqF() { 20b <= 19b; }
Bool bLessEqT() { 20b <= 20b; }
Bool bGreaterF() { 20b > 30b; }
Bool bGreaterT() { 20b > 10b; }
Bool bGreaterEqF() { 20b >= 21b; }
Bool bGreaterEqT() { 20b >= 20b; }
Bool bEqF() { 20b == 22b; }
Bool bEqT() { 20b == 20b; }
Bool bNeqF() { 20b != 20b; }
Bool bNeqT() { 20b != 22b; }
Byte bDelta10() { 20b.delta(30b); }
Byte bDelta11() { 20b.delta(9b); }
Byte bMin10() { 10b.min(20b); }
Byte bMin11() { 21b.min(11b); }
Byte bMax20() { 10b.max(20b); }
Byte bMax11() { 11b.max(9b); }

// Long
Long lConst31() { 31; }
Long lConst32() { 32l; }
Long lAdd32() { 30l + 2l; }
Long lSub20() { 25l - 5l; }
Long lMul20() { 4l * 5l; }
Long lDiv60() { 120l / 2l; }
Long lMod20() { 120l % 100l; }
Long lInc14() { Long i = 10; i += 4; i; }
Long lDec16() { Long i = 18; i -= 2; i; }
Long lMulEq8() { Long i = 4; i *= 2; i; }
Long lDivEq8() { Long i = 16; i /= 2; i; }
Long lModEq5() { Long i = 15; i %= 10; i; }
Long lInc28() { Long i = 26; i++; ++i; }
Long lInc27() { Long i = 26; ++i; i++; }
Long lDec24() { Long i = 26; i--; --i; }
Long lDec25() { Long i = 26; --i; i--; }
Long lAssign22() { Long i = 22; Long j = 5; j = i; j; }
Bool lLessF() { 20l < 10l; }
Bool lLessT() { 20l < 21l; }
Bool lLessEqF() { 20l <= 19l; }
Bool lLessEqT() { 20l <= 20l; }
Bool lGreaterF() { 20l > 30l; }
Bool lGreaterT() { 20l > 10l; }
Bool lGreaterEqF() { 20l >= 21l; }
Bool lGreaterEqT() { 20l >= 20l; }
Bool lEqF() { 20l == 22l; }
Bool lEqT() { 20l == 20l; }
Bool lNeqF() { 20l != 20l; }
Bool lNeqT() { 20l != 22l; }
Long lDelta10() { 20l.delta(30l); }
Long lDelta11() { 20l.delta(9l); }
Long lDelta50() { 20l.delta(-30l); }
Long lDelta29() { (-20l).delta(9l); }
Long lMin10() { 10l.min(20l); }
Long lMin11() { 21l.min(11l); }
Long lMinN10() { (-10l).min(20l); }
Long lMinN9() { 10l.min(-9l); }
Long lMax20() { 10l.max(20l); }
Long lMax11() { 11l.max(9l); }
Long lMax23() { 23l.max(-20l); }
Long lMax22() { (-10l).max(22l); }
Long lNegN2() { -(2l); }

// Word
Word wConst131() { 131; }
Word wConst123() { 123w; }
Word wAdd132() { 130w + 2w; }
Word wSub120() { 125w - 5w; }
Word wMul120() { 24w * 5w; }
Word wDiv160() { 320w / 2w; }
Word wMod120() { 1120w % 1000w; }
Word wInc114() { Word i = 110; i += 4; i; }
Word wDec116() { Word i = 118; i -= 2; i; }
Word wMulEq8() { Word i = 4; i *= 2; i; }
Word wDivEq8() { Word i = 16; i /= 2; i; }
Word wModEq8() { Word i = 18; i %= 10; i; }
Word wInc128() { Word i = 126; i++; ++i; }
Word wInc127() { Word i = 126; ++i; i++; }
Word wDec124() { Word i = 126; i--; --i; }
Word wDec125() { Word i = 126; --i; i--; }
Word wAssign122() { Word i = 122; Word j = 5; j = i; j; }
Bool wLessF() { 20w < 10w; }
Bool wLessT() { 20w < 21w; }
Bool wLessEqF() { 20w <= 19w; }
Bool wLessEqT() { 20w <= 20w; }
Bool wGreaterF() { 20w > 30w; }
Bool wGreaterT() { 20w > 10w; }
Bool wGreaterEqF() { 20w >= 21w; }
Bool wGreaterEqT() { 20w >= 20w; }
Bool wEqF() { 20w == 22w; }
Bool wEqT() { 20w == 20w; }
Bool wNeqF() { 20w != 20w; }
Bool wNeqT() { 20w != 22w; }
Word wDelta10() { 20w.delta(30w); }
Word wDelta11() { 20w.delta(9w); }
Word wMin10() { 10w.min(20w); }
Word wMin11() { 21w.min(11w); }
Word wMax20() { 10w.max(20w); }
Word wMax11() { 11w.max(9w); }
Word wAnd12() { 13w & 0xFE_w; }
Word wOr10() { 8w | 2w; }
Word wXor9() { 10w ^ 3w; }
Word wNeg65535() { ~0xFFFFFFFFFFFF0000_w; }
Word wAndEq12() { Word v = 13; v &= 0xFE_w; v; }
Word wOrEq10() { Word v = 2; v |= 8w; v; }
Word wXorEq9() { Word v = 10; v ^= 3w; v; }


// Float
Float fConst120() { 120; }
Float fConst121() { 121.0; }
Float fConst122() { 122f; }
Float fConst123() { 123.0f; }
Float fAdd124() { 123.5f + 0.5f; }
Float fSub100() { 120.5f - 20.5f; }
Float fMul20() { 8.0f * 2.5f; }
Float fDiv8() { 20.0f / 2.5f; }
Float fAssign20() { Float f = 20.0; Float g = 2.0; g = f; g; }
Float fCall124() { fConst120() + 4.0f; }
Float fNegN81() { -(81.0f); }
Bool fLessF() { 20.0f < 10.0f; }
Bool fLessT() { 20.0f < 20.1f; }
Bool fLessEqF() { 20.0f <= 19.0f; }
Bool fLessEqT() { 20.0f <= 20.0f; }
Bool fGreaterF() { 20.0f > 30.0f; }
Bool fGreaterT() { 20.0f > 10.0f; }
Bool fGreaterEqF() { 20.0f >= 21.0f; }
Bool fGreaterEqT() { 20.0f >= 20.0f; }
Bool fEqF() { 20.0f == 20.1f; }
Bool fEqT() { 20.0f == 20.0f; }
Bool fNeqF() { 20.0f != 20.0f; }
Bool fNeqT() { 20.0f != 20.1f; }

// Double
Double dConst120() { 120; }
Double dConst121() { 121.0; }
Double dConst122() { 122d; }
Double dConst123() { 123.0d; }
Double dAdd124() { 123.5d + 0.5d; }
Double dSub100() { 120.5d - 20.5d; }
Double dMul20() { 8.0d * 2.5d; }
Double dDiv8() { 20.0d / 2.5d; }
Double dAssign20() { Double f = 20.0; Double g = 2.0; g = f; g; }
Double dCall124() { dConst120() + 4.0; }
Double dNegN81() { -(81.0d); }
Bool dLessF() { 20.0d < 10.0d; }
Bool dLessT() { 20.0d < 20.1d; }
Bool dLessEqF() { 20.0d <= 19.0d; }
Bool dLessEqT() { 20.0d <= 20.0d; }
Bool dGreaterF() { 20.0d > 30.0d; }
Bool dGreaterT() { 20.0d > 10.0d; }
Bool dGreaterEqF() { 20.0d >= 21.0d; }
Bool dGreaterEqT() { 20.0d >= 20.0d; }
Bool dEqF() { 20.0d == 20.1d; }
Bool dEqT() { 20.0d == 20.0d; }
Bool dNeqF() { 20.0d != 20.0d; }
Bool dNeqT() { 20.0d != 20.1d; }

// Conversion tests.
// Int ->
Byte intByte20() { 20i.byte; }
Nat intNat20() { 20i.nat; }
Long intLong20() { 20i.long; }
Word intWord20() { 20i.word; }
Float intFloat20() { 20i.float; }
Double intDouble20() { 20i.double; }
Byte autoIntByte20() { 20; }
Nat autoIntNat20() { 20; }
Long autoIntLong20() { 20; }
Word autoIntWord20() { 20; }
Long autoIntLong12() { 12n.int; }
Float autoIntFloat20() { 20; }
Double autoIntDouble20() { 20; }

// Nat ->
Byte natByte20() { 20n.byte; }
Int natInt20() { 20n.int; }
Long natLong20() { 20n.long; }
Word natWord20() { 20n.word; }
Word autoNatWord12() { 12n; }

// Byte ->
Int byteInt20() { 20b.int; }
Nat byteNat20() { 20b.nat; }
Long byteLong20() { 20b.long; }
Word byteWord20() { 20b.word; }
Nat autoByteNat20() { 20b; }
Word autoByteWord20() { 20b; }

// Long ->
Byte longByte20() { 20l.byte; }
Int longInt20() { 20l.int; }
Nat longNat20() { 20l.nat; }
Word longWord20() { 20l.word; }
Float longFloat20() { 20l.float; }
Double longDouble20() { 20l.double; }

// Word ->
Byte wordByte20() { 20w.byte; }
Int wordInt20() { 20w.int; }
Nat wordNat20() { 20w.nat; }
Long wordLong20() { 20w.long; }

// Float ->
Int floatInt23() { 23.0f.int; }
Long floatLong32() { 32.0f.long; }

// Double ->
Int doubleInt23() { 23.0d.int; }
Long doubleLong32() { 32.0d.long; }