pascalabcnet/TestSuite/enum3.pas

type TEnum =(a0,
a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20,
a21,a22,a23,a24,a25,a26,a27,a28,a29,a30,a31,a32,a33,a34,a35,a36,a37,a38,a39,a40,
a41,a42,a43,a44,a45,a46,a47,a48,a49,a50,a51,a52,a53,a54,a55,a56,a57,a58,a59,a60,
a61,a62,a63,a64,a65,a66,a67,a68,a69,a70,a71,a72,a73,a74,a75,a76,a77,a78,a79,a80,
a81,a82,a83,a84,a85,a86,a87,a88,a89,a90,a91,a92,a93,a94,a95,a96,a97,a98,a99,a100,
a101,a102,a103,a104,a105,a106,a107,a108,a109,a110,a111,a112,a113,a114,a115,a116,a117,a118,a119,a120,
a121,a122,a123,a124,a125,a126,a127,a128,a129,a130,a131,a132,a133,a134,a135,a136,a137,a138,a139,a140,
a141,a142,a143,a144,a145,a146,a147,a148,a149,a150,a151,a152,a153,a154,a155,a156,a157,a158,a159,a160,
a161,a162,a163,a164,a165,a166,a167,a168,a169,a170,a171,a172,a173,a174,a175,a176,a177,a178,a179,a180,
a181,a182,a183,a184,a185,a186,a187,a188,a189,a190,a191,a192,a193,a194,a195,a196,a197,a198,a199,a200,
a201,a202,a203,a204,a205,a206,a207,a208,a209,a210,a211,a212,a213,a214,a215,a216,a217,a218,a219,a220,
a221,a222,a223,a224,a225,a226,a227,a228,a229,a230,a231,a232,a233,a234,a235,a236,a237,a238,a239,a240,
a241,a242,a243,a244,a245,a246,a247,a248,a249,a250,a251,a252,a253,a254,a255,a256,a257,a258,a259,a260,
a261,a262,a263,a264,a265,a266,a267,a268,a269,a270,a271,a272,a273,a274,a275,a276,a277,a278,a279,a280,
a281,a282,a283,a284,a285,a286,a287,a288,a289,a290,a291,a292,a293,a294,a295,a296,a297,a298,a299,a300
);
var a : TEnum;
begin
assert(integer(a0)=0);
assert(smallint(a0)=0);
assert(int64(a0)=0);
assert(integer(a1)=1);
assert(smallint(a1)=1);
assert(int64(a1)=1);
assert(integer(a2)=2);
assert(smallint(a2)=2);
assert(int64(a2)=2);
assert(integer(a3)=3);
assert(smallint(a3)=3);
assert(int64(a3)=3);
assert(integer(a4)=4);
assert(smallint(a4)=4);
assert(int64(a4)=4);
assert(integer(a5)=5);
assert(smallint(a5)=5);
assert(int64(a5)=5);
assert(integer(a6)=6);
assert(smallint(a6)=6);
assert(int64(a6)=6);
assert(integer(a7)=7);
assert(smallint(a7)=7);
assert(int64(a7)=7);
assert(integer(a8)=8);
assert(smallint(a8)=8);
assert(int64(a8)=8);
assert(integer(a9)=9);
assert(smallint(a9)=9);
assert(int64(a9)=9);
assert(integer(a10)=10);
assert(smallint(a10)=10);
assert(int64(a10)=10);
assert(integer(a11)=11);
assert(smallint(a11)=11);
assert(int64(a11)=11);
assert(integer(a12)=12);
assert(smallint(a12)=12);
assert(int64(a12)=12);
assert(integer(a13)=13);
assert(smallint(a13)=13);
assert(int64(a13)=13);
assert(integer(a14)=14);
assert(smallint(a14)=14);
assert(int64(a14)=14);
assert(integer(a15)=15);
assert(smallint(a15)=15);
assert(int64(a15)=15);
assert(integer(a16)=16);
assert(smallint(a16)=16);
assert(int64(a16)=16);
assert(integer(a17)=17);
assert(smallint(a17)=17);
assert(int64(a17)=17);
assert(integer(a18)=18);
assert(smallint(a18)=18);
assert(int64(a18)=18);
assert(integer(a19)=19);
assert(smallint(a19)=19);
assert(int64(a19)=19);
assert(integer(a20)=20);
assert(smallint(a20)=20);
assert(int64(a20)=20);
assert(integer(a21)=21);
assert(smallint(a21)=21);
assert(int64(a21)=21);
assert(integer(a22)=22);
assert(smallint(a22)=22);
assert(int64(a22)=22);
assert(integer(a23)=23);
assert(smallint(a23)=23);
assert(int64(a23)=23);
assert(integer(a24)=24);
assert(smallint(a24)=24);
assert(int64(a24)=24);
assert(integer(a25)=25);
assert(smallint(a25)=25);
assert(int64(a25)=25);
assert(integer(a26)=26);
assert(smallint(a26)=26);
assert(int64(a26)=26);
assert(integer(a27)=27);
assert(smallint(a27)=27);
assert(int64(a27)=27);
assert(integer(a28)=28);
assert(smallint(a28)=28);
assert(int64(a28)=28);
assert(integer(a29)=29);
assert(smallint(a29)=29);
assert(int64(a29)=29);
assert(integer(a30)=30);
assert(smallint(a30)=30);
assert(int64(a30)=30);
assert(integer(a31)=31);
assert(smallint(a31)=31);
assert(int64(a31)=31);
assert(integer(a32)=32);
assert(smallint(a32)=32);
assert(int64(a32)=32);
assert(integer(a33)=33);
assert(smallint(a33)=33);
assert(int64(a33)=33);
assert(integer(a34)=34);
assert(smallint(a34)=34);
assert(int64(a34)=34);
assert(integer(a35)=35);
assert(smallint(a35)=35);
assert(int64(a35)=35);
assert(integer(a36)=36);
assert(smallint(a36)=36);
assert(int64(a36)=36);
assert(integer(a37)=37);
assert(smallint(a37)=37);
assert(int64(a37)=37);
assert(integer(a38)=38);
assert(smallint(a38)=38);
assert(int64(a38)=38);
assert(integer(a39)=39);
assert(smallint(a39)=39);
assert(int64(a39)=39);
assert(integer(a40)=40);
assert(smallint(a40)=40);
assert(int64(a40)=40);
assert(integer(a41)=41);
assert(smallint(a41)=41);
assert(int64(a41)=41);
assert(integer(a42)=42);
assert(smallint(a42)=42);
assert(int64(a42)=42);
assert(integer(a43)=43);
assert(smallint(a43)=43);
assert(int64(a43)=43);
assert(integer(a44)=44);
assert(smallint(a44)=44);
assert(int64(a44)=44);
assert(integer(a45)=45);
assert(smallint(a45)=45);
assert(int64(a45)=45);
assert(integer(a46)=46);
assert(smallint(a46)=46);
assert(int64(a46)=46);
assert(integer(a47)=47);
assert(smallint(a47)=47);
assert(int64(a47)=47);
assert(integer(a48)=48);
assert(smallint(a48)=48);
assert(int64(a48)=48);
assert(integer(a49)=49);
assert(smallint(a49)=49);
assert(int64(a49)=49);
assert(integer(a50)=50);
assert(smallint(a50)=50);
assert(int64(a50)=50);
assert(integer(a51)=51);
assert(smallint(a51)=51);
assert(int64(a51)=51);
assert(integer(a52)=52);
assert(smallint(a52)=52);
assert(int64(a52)=52);
assert(integer(a53)=53);
assert(smallint(a53)=53);
assert(int64(a53)=53);
assert(integer(a54)=54);
assert(smallint(a54)=54);
assert(int64(a54)=54);
assert(integer(a55)=55);
assert(smallint(a55)=55);
assert(int64(a55)=55);
assert(integer(a56)=56);
assert(smallint(a56)=56);
assert(int64(a56)=56);
assert(integer(a57)=57);
assert(smallint(a57)=57);
assert(int64(a57)=57);
assert(integer(a58)=58);
assert(smallint(a58)=58);
assert(int64(a58)=58);
assert(integer(a59)=59);
assert(smallint(a59)=59);
assert(int64(a59)=59);
assert(integer(a60)=60);
assert(smallint(a60)=60);
assert(int64(a60)=60);
assert(integer(a61)=61);
assert(smallint(a61)=61);
assert(int64(a61)=61);
assert(integer(a62)=62);
assert(smallint(a62)=62);
assert(int64(a62)=62);
assert(integer(a63)=63);
assert(smallint(a63)=63);
assert(int64(a63)=63);
assert(integer(a64)=64);
assert(smallint(a64)=64);
assert(int64(a64)=64);
assert(integer(a65)=65);
assert(smallint(a65)=65);
assert(int64(a65)=65);
assert(integer(a66)=66);
assert(smallint(a66)=66);
assert(int64(a66)=66);
assert(integer(a67)=67);
assert(smallint(a67)=67);
assert(int64(a67)=67);
assert(integer(a68)=68);
assert(smallint(a68)=68);
assert(int64(a68)=68);
assert(integer(a69)=69);
assert(smallint(a69)=69);
assert(int64(a69)=69);
assert(integer(a70)=70);
assert(smallint(a70)=70);
assert(int64(a70)=70);
assert(integer(a71)=71);
assert(smallint(a71)=71);
assert(int64(a71)=71);
assert(integer(a72)=72);
assert(smallint(a72)=72);
assert(int64(a72)=72);
assert(integer(a73)=73);
assert(smallint(a73)=73);
assert(int64(a73)=73);
assert(integer(a74)=74);
assert(smallint(a74)=74);
assert(int64(a74)=74);
assert(integer(a75)=75);
assert(smallint(a75)=75);
assert(int64(a75)=75);
assert(integer(a76)=76);
assert(smallint(a76)=76);
assert(int64(a76)=76);
assert(integer(a77)=77);
assert(smallint(a77)=77);
assert(int64(a77)=77);
assert(integer(a78)=78);
assert(smallint(a78)=78);
assert(int64(a78)=78);
assert(integer(a79)=79);
assert(smallint(a79)=79);
assert(int64(a79)=79);
assert(integer(a80)=80);
assert(smallint(a80)=80);
assert(int64(a80)=80);
assert(integer(a81)=81);
assert(smallint(a81)=81);
assert(int64(a81)=81);
assert(integer(a82)=82);
assert(smallint(a82)=82);
assert(int64(a82)=82);
assert(integer(a83)=83);
assert(smallint(a83)=83);
assert(int64(a83)=83);
assert(integer(a84)=84);
assert(smallint(a84)=84);
assert(int64(a84)=84);
assert(integer(a85)=85);
assert(smallint(a85)=85);
assert(int64(a85)=85);
assert(integer(a86)=86);
assert(smallint(a86)=86);
assert(int64(a86)=86);
assert(integer(a87)=87);
assert(smallint(a87)=87);
assert(int64(a87)=87);
assert(integer(a88)=88);
assert(smallint(a88)=88);
assert(int64(a88)=88);
assert(integer(a89)=89);
assert(smallint(a89)=89);
assert(int64(a89)=89);
assert(integer(a90)=90);
assert(smallint(a90)=90);
assert(int64(a90)=90);
assert(integer(a91)=91);
assert(smallint(a91)=91);
assert(int64(a91)=91);
assert(integer(a92)=92);
assert(smallint(a92)=92);
assert(int64(a92)=92);
assert(integer(a93)=93);
assert(smallint(a93)=93);
assert(int64(a93)=93);
assert(integer(a94)=94);
assert(smallint(a94)=94);
assert(int64(a94)=94);
assert(integer(a95)=95);
assert(smallint(a95)=95);
assert(int64(a95)=95);
assert(integer(a96)=96);
assert(smallint(a96)=96);
assert(int64(a96)=96);
assert(integer(a97)=97);
assert(smallint(a97)=97);
assert(int64(a97)=97);
assert(integer(a98)=98);
assert(smallint(a98)=98);
assert(int64(a98)=98);
assert(integer(a99)=99);
assert(smallint(a99)=99);
assert(int64(a99)=99);
assert(integer(a100)=100);
assert(smallint(a100)=100);
assert(int64(a100)=100);
assert(integer(a101)=101);
assert(smallint(a101)=101);
assert(int64(a101)=101);
assert(integer(a102)=102);
assert(smallint(a102)=102);
assert(int64(a102)=102);
assert(integer(a103)=103);
assert(smallint(a103)=103);
assert(int64(a103)=103);
assert(integer(a104)=104);
assert(smallint(a104)=104);
assert(int64(a104)=104);
assert(integer(a105)=105);
assert(smallint(a105)=105);
assert(int64(a105)=105);
assert(integer(a106)=106);
assert(smallint(a106)=106);
assert(int64(a106)=106);
assert(integer(a107)=107);
assert(smallint(a107)=107);
assert(int64(a107)=107);
assert(integer(a108)=108);
assert(smallint(a108)=108);
assert(int64(a108)=108);
assert(integer(a109)=109);
assert(smallint(a109)=109);
assert(int64(a109)=109);
assert(integer(a110)=110);
assert(smallint(a110)=110);
assert(int64(a110)=110);
assert(integer(a111)=111);
assert(smallint(a111)=111);
assert(int64(a111)=111);
assert(integer(a112)=112);
assert(smallint(a112)=112);
assert(int64(a112)=112);
assert(integer(a113)=113);
assert(smallint(a113)=113);
assert(int64(a113)=113);
assert(integer(a114)=114);
assert(smallint(a114)=114);
assert(int64(a114)=114);
assert(integer(a115)=115);
assert(smallint(a115)=115);
assert(int64(a115)=115);
assert(integer(a116)=116);
assert(smallint(a116)=116);
assert(int64(a116)=116);
assert(integer(a117)=117);
assert(smallint(a117)=117);
assert(int64(a117)=117);
assert(integer(a118)=118);
assert(smallint(a118)=118);
assert(int64(a118)=118);
assert(integer(a119)=119);
assert(smallint(a119)=119);
assert(int64(a119)=119);
assert(integer(a120)=120);
assert(smallint(a120)=120);
assert(int64(a120)=120);
assert(integer(a121)=121);
assert(smallint(a121)=121);
assert(int64(a121)=121);
assert(integer(a122)=122);
assert(smallint(a122)=122);
assert(int64(a122)=122);
assert(integer(a123)=123);
assert(smallint(a123)=123);
assert(int64(a123)=123);
assert(integer(a124)=124);
assert(smallint(a124)=124);
assert(int64(a124)=124);
assert(integer(a125)=125);
assert(smallint(a125)=125);
assert(int64(a125)=125);
assert(integer(a126)=126);
assert(smallint(a126)=126);
assert(int64(a126)=126);
assert(integer(a127)=127);
assert(smallint(a127)=127);
assert(int64(a127)=127);
assert(integer(a128)=128);
assert(smallint(a128)=128);
assert(int64(a128)=128);
assert(integer(a129)=129);
assert(smallint(a129)=129);
assert(int64(a129)=129);
assert(integer(a130)=130);
assert(smallint(a130)=130);
assert(int64(a130)=130);
assert(integer(a131)=131);
assert(smallint(a131)=131);
assert(int64(a131)=131);
assert(integer(a132)=132);
assert(smallint(a132)=132);
assert(int64(a132)=132);
assert(integer(a133)=133);
assert(smallint(a133)=133);
assert(int64(a133)=133);
assert(integer(a134)=134);
assert(smallint(a134)=134);
assert(int64(a134)=134);
assert(integer(a135)=135);
assert(smallint(a135)=135);
assert(int64(a135)=135);
assert(integer(a136)=136);
assert(smallint(a136)=136);
assert(int64(a136)=136);
assert(integer(a137)=137);
assert(smallint(a137)=137);
assert(int64(a137)=137);
assert(integer(a138)=138);
assert(smallint(a138)=138);
assert(int64(a138)=138);
assert(integer(a139)=139);
assert(smallint(a139)=139);
assert(int64(a139)=139);
assert(integer(a140)=140);
assert(smallint(a140)=140);
assert(int64(a140)=140);
assert(integer(a141)=141);
assert(smallint(a141)=141);
assert(int64(a141)=141);
assert(integer(a142)=142);
assert(smallint(a142)=142);
assert(int64(a142)=142);
assert(integer(a143)=143);
assert(smallint(a143)=143);
assert(int64(a143)=143);
assert(integer(a144)=144);
assert(smallint(a144)=144);
assert(int64(a144)=144);
assert(integer(a145)=145);
assert(smallint(a145)=145);
assert(int64(a145)=145);
assert(integer(a146)=146);
assert(smallint(a146)=146);
assert(int64(a146)=146);
assert(integer(a147)=147);
assert(smallint(a147)=147);
assert(int64(a147)=147);
assert(integer(a148)=148);
assert(smallint(a148)=148);
assert(int64(a148)=148);
assert(integer(a149)=149);
assert(smallint(a149)=149);
assert(int64(a149)=149);
assert(integer(a150)=150);
assert(smallint(a150)=150);
assert(int64(a150)=150);
assert(integer(a151)=151);
assert(smallint(a151)=151);
assert(int64(a151)=151);
assert(integer(a152)=152);
assert(smallint(a152)=152);
assert(int64(a152)=152);
assert(integer(a153)=153);
assert(smallint(a153)=153);
assert(int64(a153)=153);
assert(integer(a154)=154);
assert(smallint(a154)=154);
assert(int64(a154)=154);
assert(integer(a155)=155);
assert(smallint(a155)=155);
assert(int64(a155)=155);
assert(integer(a156)=156);
assert(smallint(a156)=156);
assert(int64(a156)=156);
assert(integer(a157)=157);
assert(smallint(a157)=157);
assert(int64(a157)=157);
assert(integer(a158)=158);
assert(smallint(a158)=158);
assert(int64(a158)=158);
assert(integer(a159)=159);
assert(smallint(a159)=159);
assert(int64(a159)=159);
assert(integer(a160)=160);
assert(smallint(a160)=160);
assert(int64(a160)=160);
assert(integer(a161)=161);
assert(smallint(a161)=161);
assert(int64(a161)=161);
assert(integer(a162)=162);
assert(smallint(a162)=162);
assert(int64(a162)=162);
assert(integer(a163)=163);
assert(smallint(a163)=163);
assert(int64(a163)=163);
assert(integer(a164)=164);
assert(smallint(a164)=164);
assert(int64(a164)=164);
assert(integer(a165)=165);
assert(smallint(a165)=165);
assert(int64(a165)=165);
assert(integer(a166)=166);
assert(smallint(a166)=166);
assert(int64(a166)=166);
assert(integer(a167)=167);
assert(smallint(a167)=167);
assert(int64(a167)=167);
assert(integer(a168)=168);
assert(smallint(a168)=168);
assert(int64(a168)=168);
assert(integer(a169)=169);
assert(smallint(a169)=169);
assert(int64(a169)=169);
assert(integer(a170)=170);
assert(smallint(a170)=170);
assert(int64(a170)=170);
assert(integer(a171)=171);
assert(smallint(a171)=171);
assert(int64(a171)=171);
assert(integer(a172)=172);
assert(smallint(a172)=172);
assert(int64(a172)=172);
assert(integer(a173)=173);
assert(smallint(a173)=173);
assert(int64(a173)=173);
assert(integer(a174)=174);
assert(smallint(a174)=174);
assert(int64(a174)=174);
assert(integer(a175)=175);
assert(smallint(a175)=175);
assert(int64(a175)=175);
assert(integer(a176)=176);
assert(smallint(a176)=176);
assert(int64(a176)=176);
assert(integer(a177)=177);
assert(smallint(a177)=177);
assert(int64(a177)=177);
assert(integer(a178)=178);
assert(smallint(a178)=178);
assert(int64(a178)=178);
assert(integer(a179)=179);
assert(smallint(a179)=179);
assert(int64(a179)=179);
assert(integer(a180)=180);
assert(smallint(a180)=180);
assert(int64(a180)=180);
assert(integer(a181)=181);
assert(smallint(a181)=181);
assert(int64(a181)=181);
assert(integer(a182)=182);
assert(smallint(a182)=182);
assert(int64(a182)=182);
assert(integer(a183)=183);
assert(smallint(a183)=183);
assert(int64(a183)=183);
assert(integer(a184)=184);
assert(smallint(a184)=184);
assert(int64(a184)=184);
assert(integer(a185)=185);
assert(smallint(a185)=185);
assert(int64(a185)=185);
assert(integer(a186)=186);
assert(smallint(a186)=186);
assert(int64(a186)=186);
assert(integer(a187)=187);
assert(smallint(a187)=187);
assert(int64(a187)=187);
assert(integer(a188)=188);
assert(smallint(a188)=188);
assert(int64(a188)=188);
assert(integer(a189)=189);
assert(smallint(a189)=189);
assert(int64(a189)=189);
assert(integer(a190)=190);
assert(smallint(a190)=190);
assert(int64(a190)=190);
assert(integer(a191)=191);
assert(smallint(a191)=191);
assert(int64(a191)=191);
assert(integer(a192)=192);
assert(smallint(a192)=192);
assert(int64(a192)=192);
assert(integer(a193)=193);
assert(smallint(a193)=193);
assert(int64(a193)=193);
assert(integer(a194)=194);
assert(smallint(a194)=194);
assert(int64(a194)=194);
assert(integer(a195)=195);
assert(smallint(a195)=195);
assert(int64(a195)=195);
assert(integer(a196)=196);
assert(smallint(a196)=196);
assert(int64(a196)=196);
assert(integer(a197)=197);
assert(smallint(a197)=197);
assert(int64(a197)=197);
assert(integer(a198)=198);
assert(smallint(a198)=198);
assert(int64(a198)=198);
assert(integer(a199)=199);
assert(smallint(a199)=199);
assert(int64(a199)=199);
assert(integer(a200)=200);
assert(smallint(a200)=200);
assert(int64(a200)=200);
assert(integer(a201)=201);
assert(smallint(a201)=201);
assert(int64(a201)=201);
assert(integer(a202)=202);
assert(smallint(a202)=202);
assert(int64(a202)=202);
assert(integer(a203)=203);
assert(smallint(a203)=203);
assert(int64(a203)=203);
assert(integer(a204)=204);
assert(smallint(a204)=204);
assert(int64(a204)=204);
assert(integer(a205)=205);
assert(smallint(a205)=205);
assert(int64(a205)=205);
assert(integer(a206)=206);
assert(smallint(a206)=206);
assert(int64(a206)=206);
assert(integer(a207)=207);
assert(smallint(a207)=207);
assert(int64(a207)=207);
assert(integer(a208)=208);
assert(smallint(a208)=208);
assert(int64(a208)=208);
assert(integer(a209)=209);
assert(smallint(a209)=209);
assert(int64(a209)=209);
assert(integer(a210)=210);
assert(smallint(a210)=210);
assert(int64(a210)=210);
assert(integer(a211)=211);
assert(smallint(a211)=211);
assert(int64(a211)=211);
assert(integer(a212)=212);
assert(smallint(a212)=212);
assert(int64(a212)=212);
assert(integer(a213)=213);
assert(smallint(a213)=213);
assert(int64(a213)=213);
assert(integer(a214)=214);
assert(smallint(a214)=214);
assert(int64(a214)=214);
assert(integer(a215)=215);
assert(smallint(a215)=215);
assert(int64(a215)=215);
assert(integer(a216)=216);
assert(smallint(a216)=216);
assert(int64(a216)=216);
assert(integer(a217)=217);
assert(smallint(a217)=217);
assert(int64(a217)=217);
assert(integer(a218)=218);
assert(smallint(a218)=218);
assert(int64(a218)=218);
assert(integer(a219)=219);
assert(smallint(a219)=219);
assert(int64(a219)=219);
assert(integer(a220)=220);
assert(smallint(a220)=220);
assert(int64(a220)=220);
assert(integer(a221)=221);
assert(smallint(a221)=221);
assert(int64(a221)=221);
assert(integer(a222)=222);
assert(smallint(a222)=222);
assert(int64(a222)=222);
assert(integer(a223)=223);
assert(smallint(a223)=223);
assert(int64(a223)=223);
assert(integer(a224)=224);
assert(smallint(a224)=224);
assert(int64(a224)=224);
assert(integer(a225)=225);
assert(smallint(a225)=225);
assert(int64(a225)=225);
assert(integer(a226)=226);
assert(smallint(a226)=226);
assert(int64(a226)=226);
assert(integer(a227)=227);
assert(smallint(a227)=227);
assert(int64(a227)=227);
assert(integer(a228)=228);
assert(smallint(a228)=228);
assert(int64(a228)=228);
assert(integer(a229)=229);
assert(smallint(a229)=229);
assert(int64(a229)=229);
assert(integer(a230)=230);
assert(smallint(a230)=230);
assert(int64(a230)=230);
assert(integer(a231)=231);
assert(smallint(a231)=231);
assert(int64(a231)=231);
assert(integer(a232)=232);
assert(smallint(a232)=232);
assert(int64(a232)=232);
assert(integer(a233)=233);
assert(smallint(a233)=233);
assert(int64(a233)=233);
assert(integer(a234)=234);
assert(smallint(a234)=234);
assert(int64(a234)=234);
assert(integer(a235)=235);
assert(smallint(a235)=235);
assert(int64(a235)=235);
assert(integer(a236)=236);
assert(smallint(a236)=236);
assert(int64(a236)=236);
assert(integer(a237)=237);
assert(smallint(a237)=237);
assert(int64(a237)=237);
assert(integer(a238)=238);
assert(smallint(a238)=238);
assert(int64(a238)=238);
assert(integer(a239)=239);
assert(smallint(a239)=239);
assert(int64(a239)=239);
assert(integer(a240)=240);
assert(smallint(a240)=240);
assert(int64(a240)=240);
assert(integer(a241)=241);
assert(smallint(a241)=241);
assert(int64(a241)=241);
assert(integer(a242)=242);
assert(smallint(a242)=242);
assert(int64(a242)=242);
assert(integer(a243)=243);
assert(smallint(a243)=243);
assert(int64(a243)=243);
assert(integer(a244)=244);
assert(smallint(a244)=244);
assert(int64(a244)=244);
assert(integer(a245)=245);
assert(smallint(a245)=245);
assert(int64(a245)=245);
assert(integer(a246)=246);
assert(smallint(a246)=246);
assert(int64(a246)=246);
assert(integer(a247)=247);
assert(smallint(a247)=247);
assert(int64(a247)=247);
assert(integer(a248)=248);
assert(smallint(a248)=248);
assert(int64(a248)=248);
assert(integer(a249)=249);
assert(smallint(a249)=249);
assert(int64(a249)=249);
assert(integer(a250)=250);
assert(smallint(a250)=250);
assert(int64(a250)=250);
assert(integer(a251)=251);
assert(smallint(a251)=251);
assert(int64(a251)=251);
assert(integer(a252)=252);
assert(smallint(a252)=252);
assert(int64(a252)=252);
assert(integer(a253)=253);
assert(smallint(a253)=253);
assert(int64(a253)=253);
assert(integer(a254)=254);
assert(smallint(a254)=254);
assert(int64(a254)=254);
assert(integer(a255)=255);
assert(smallint(a255)=255);
assert(int64(a255)=255);
assert(integer(a256)=256);
assert(smallint(a256)=256);
assert(int64(a256)=256);
assert(integer(a257)=257);
assert(smallint(a257)=257);
assert(int64(a257)=257);
assert(integer(a258)=258);
assert(smallint(a258)=258);
assert(int64(a258)=258);
assert(integer(a259)=259);
assert(smallint(a259)=259);
assert(int64(a259)=259);
assert(integer(a260)=260);
assert(smallint(a260)=260);
assert(int64(a260)=260);
assert(integer(a261)=261);
assert(smallint(a261)=261);
assert(int64(a261)=261);
assert(integer(a262)=262);
assert(smallint(a262)=262);
assert(int64(a262)=262);
assert(integer(a263)=263);
assert(smallint(a263)=263);
assert(int64(a263)=263);
assert(integer(a264)=264);
assert(smallint(a264)=264);
assert(int64(a264)=264);
assert(integer(a265)=265);
assert(smallint(a265)=265);
assert(int64(a265)=265);
assert(integer(a266)=266);
assert(smallint(a266)=266);
assert(int64(a266)=266);
assert(integer(a267)=267);
assert(smallint(a267)=267);
assert(int64(a267)=267);
assert(integer(a268)=268);
assert(smallint(a268)=268);
assert(int64(a268)=268);
assert(integer(a269)=269);
assert(smallint(a269)=269);
assert(int64(a269)=269);
assert(integer(a270)=270);
assert(smallint(a270)=270);
assert(int64(a270)=270);
assert(integer(a271)=271);
assert(smallint(a271)=271);
assert(int64(a271)=271);
assert(integer(a272)=272);
assert(smallint(a272)=272);
assert(int64(a272)=272);
assert(integer(a273)=273);
assert(smallint(a273)=273);
assert(int64(a273)=273);
assert(integer(a274)=274);
assert(smallint(a274)=274);
assert(int64(a274)=274);
assert(integer(a275)=275);
assert(smallint(a275)=275);
assert(int64(a275)=275);
assert(integer(a276)=276);
assert(smallint(a276)=276);
assert(int64(a276)=276);
assert(integer(a277)=277);
assert(smallint(a277)=277);
assert(int64(a277)=277);
assert(integer(a278)=278);
assert(smallint(a278)=278);
assert(int64(a278)=278);
assert(integer(a279)=279);
assert(smallint(a279)=279);
assert(int64(a279)=279);
assert(integer(a280)=280);
assert(smallint(a280)=280);
assert(int64(a280)=280);
assert(integer(a281)=281);
assert(smallint(a281)=281);
assert(int64(a281)=281);
assert(integer(a282)=282);
assert(smallint(a282)=282);
assert(int64(a282)=282);
assert(integer(a283)=283);
assert(smallint(a283)=283);
assert(int64(a283)=283);
assert(integer(a284)=284);
assert(smallint(a284)=284);
assert(int64(a284)=284);
assert(integer(a285)=285);
assert(smallint(a285)=285);
assert(int64(a285)=285);
assert(integer(a286)=286);
assert(smallint(a286)=286);
assert(int64(a286)=286);
assert(integer(a287)=287);
assert(smallint(a287)=287);
assert(int64(a287)=287);
assert(integer(a288)=288);
assert(smallint(a288)=288);
assert(int64(a288)=288);
assert(integer(a289)=289);
assert(smallint(a289)=289);
assert(int64(a289)=289);
assert(integer(a290)=290);
assert(smallint(a290)=290);
assert(int64(a290)=290);
assert(integer(a291)=291);
assert(smallint(a291)=291);
assert(int64(a291)=291);
assert(integer(a292)=292);
assert(smallint(a292)=292);
assert(int64(a292)=292);
assert(integer(a293)=293);
assert(smallint(a293)=293);
assert(int64(a293)=293);
assert(integer(a294)=294);
assert(smallint(a294)=294);
assert(int64(a294)=294);
assert(integer(a295)=295);
assert(smallint(a295)=295);
assert(int64(a295)=295);
assert(integer(a296)=296);
assert(smallint(a296)=296);
assert(int64(a296)=296);
assert(integer(a297)=297);
assert(smallint(a297)=297);
assert(int64(a297)=297);
assert(integer(a298)=298);
assert(smallint(a298)=298);
assert(int64(a298)=298);
assert(integer(a299)=299);
assert(smallint(a299)=299);
assert(int64(a299)=299);
assert(integer(a300)=300);
assert(smallint(a300)=300);
assert(int64(a300)=300);
end.