a = 2 + "";
	print				'5054: a = 2 + ""';
	g = fopen(3, "r");
	print				'5055: g = fopen(3, "r")';
	c = 5^2;
	print				'5056: c = 5^2';
	vrfy(errcount() == ecnt,	'5057: errcount() == ecnt');

	/* generate 4 more errors by testing newerror */
	ecnt += 4;
	print				'5058: ecnt += 4';
	a = newerror("alpha");
	print				'5059: a = newerror("alpha")';
	b = newerror("beta");
	print				'5060: b = newerror("beta")';
	c = newerror("alpha");
	print				'5061: c = newerror("alpha")';
	d = newerror("beta");
	print				'5062: d = newerror("beta")';
	vrfy(errcount() == ecnt,	'5063: errcount() == ecnt');
	vrfy(a == c,			'5064: a == c');
	vrfy(b == d,			'5065: b == d');

	/* test error(0) */
	error(0);
	print				'5066: error(0)';
	vrfy(strerror() == "No error",	'5067: strerror() == "No error"');

	/*
	 * close down
	 */
	fclose(f);
	print				'5068: fclose(f)';
	rm("junk5000");
	print				'5069: rm("junk5000")';

	print '5070: Ending test_filesearch';
}
print '125: parsed test_filesearch()';


/*
 * test_newdecl - test the new code generator declaration scope and order
 */
read -once "test5100";
print '126: read -once test5100';
/**/
define test_newdecl()
{

	print '5100: Beginning test_newdecl';

	/*
	 * test5100 calls
	 */
	test5100(1);
	print				'5101: test5100(1)';
	vrfy(a5100 == 0,		'5102: a5100 == 0');
	vrfy(b5100 == 2,		'5103: b5100 == 2');
	test5100(1);
	print				'5104: test5100(1)';
	vrfy(a5100 == 0,		'5105: a5100 == 0');
	vrfy(b5100 == 3,		'5106: b5100 == 3');
	test5100(1);
	print				'5107: test5100(1)';
	vrfy(a5100 == 0,		'5108: a5100 == 0');
	vrfy(b5100 == 4,		'5109: b5100 == 4');
	test5100(2);
	print				'5110: test5100(2)';
	vrfy(a5100 == 3,		'5111: a5100 == 3');
	vrfy(b5100 == 4,		'5112: b5100 == 4');
	test5100(2);
	print				'5113: test5100(2)';
	vrfy(a5100 == 4,		'5114: a5100 == 4');
	vrfy(b5100 == 4,		'5115: b5100 == 4');
	test5100(2);
	print				'5116: test5100(2)';
	vrfy(a5100 == 5,		'5117: a5100 == 5');
	vrfy(b5100 == 4,		'5118: b5100 == 4');
	test5100(3);
	print				'5119: test5100(3)';
	vrfy(a5100 == 5,		'5120: a5100 == 5');
	vrfy(b5100 == 5,		'5121: b5100 == 5');
	test5100(9);
	print				'5122: test5100(9)';
	vrfy(a5100 == 5,		'5123: a5100 == 5');
	vrfy(b5100 == 6,		'5124: b5100 == 6');
	test5100(0);
	print				'5125: test5100(0)';
	vrfy(a5100 == 5,		'5126: a5100 == 5');
	vrfy(b5100 == 6,		'5127: b5100 == 6');
	test5100(-1);
	print				'5128: test5100(-1)';
	vrfy(a5100 == 5,		'5129: a5100 == 5');
	vrfy(b5100 == 6,		'5130: b5100 == 6');

	print '5131: Ending test_newdecl';

}
print '127: parsed test_newdecl()';


/*
 * test_globstat - test the fix of a global/static bug
 */
read -once "test5200";
print '128: read -once test5200';
/**/
define test_globstat()
{
	print '5200: Beginning test_globstat';

	/*
	 * test {f,g,h}5200 calls
	 */
	vrfy(a5200 == 10,		'5201: a5200 == 10');
	vrfy(eval("a5200") == 10,	'5202: eval("a5200") == 10');
	vrfy(f5200(1) == 21,		'5203: f5200(1) == 21');
	vrfy(a5200 == 10,		'5204: a5200 == 10');
	vrfy(eval("a5200") == 10,	'5205: eval("a5200") == 10');
	vrfy(h5200(2) == 12,		'5206: h5200(2) == 12');
	vrfy(a5200 == 10,		'5207: a5200 == 10');
	vrfy(eval("a5200") == 10,	'5208: eval("a5200") == 10');
	vrfy(g5200(3) == 33,		'5209: g5200(3) == 33');
	vrfy(a5200 == 30,		'5210: a5200 == 30');
	vrfy(eval("a5200") == 30,	'5211: eval("a5200") == 30');
	vrfy(h5200(4) == 34,		'5212: h5200(4) == 34');
	vrfy(f5200(5) == 25,		'5213: f5200(5) == 25');
	vrfy(h5200(6) == 36,		'5214: h5200(6) == 36');
	vrfy(g5200(7) == 37,		'5215: g5200(7) == 37');
	vrfy(f5200(8) == 28,		'5216: f5200(8) == 28');
	vrfy(g5200(9) == 39,		'5217: g5200(9) == 39');
	vrfy(a5200 == 30,		'5218: a5200 == 30');
	vrfy(eval("a5200") == 30,	'5219: eval("a5200") == 30');

	print '5220: Ending test_globstat';
}
print '129: parsed test_globstat()';


/*
 * test_newop2 - test new label stuff
 */
define test_newop2(x) {if (x < 0) goto l130; ++x; l130: return x;}
print '130: define test_newop3(x) {if (x < 0) goto l130; ++x; l130: return x;}'
vrfy(test_newop2(100) == 101,		'131: test_newop2(100) == 101');
vrfy(test_newop2(-100) == -100,		'132: test_newop2(-100) == -100');


/*
 * test_newop3 - test new label stuff
 */
define test_newop3(x) {
	if (x < 4)
		if (iseven(x))
			goto l135;
		else
			return 2;
	return 3;
	l135:
		return 1;
}
print '133: define test_newop3(x) ...';
vrfy(test_newop3(2) == 1,		'134: test_newop3(2) == 1');
vrfy(test_newop3(3) == 2,		'135: test_newop3(3) == 2');
vrfy(test_newop3(4) == 3,		'136: test_newop3(4) == 3');


/*
 * Test random - Blum-Blum-Shub pseudo-random number generator
 */
define test_random()
{
	local init;		/* initial generator state */
	local state0;		/* a generator state */
	local state1;		/* a generator state */
	local tmp;
	local n;

	print '5300: Beginning random test';

	/* test save and restore of the initial state */
	tmp = srandom(0);
	print				  '5301: tmp = srandom(0)';
	init = srandom();
	print				  '5302: init = srandom()';
	state0 = srandom(0);
	print				  '5303: state0 = srandom(0)';
	vrfy(state0 == init,		  '5304: state0 == init');

	/* test the additive 55 shuffle generator */
	tmp = srandom(0);
	print				  '5305: tmp = srandom(0)';
	vrfy(random() == 0x7fb838a8a0a95046, \
		  '5306: random() == 0x7fb838a8a0a95046');
	vrfy(random() == 0xb9d9d9fb4440f7bb, \
		  '5307: random() == 0xb9d9d9fb4440f7bb');
	tmp = srandom(init);
	print				  '5308: tmp = srandom(init)';
	vrfy(random() == 0x7fb838a8a0a95046, \
		  '5309: random() == 0x7fb838a8a0a95046');
	vrfy(random() == 0xb9d9d9fb4440f7bb, \
		  '5310: random() == 0xb9d9d9fb4440f7bb');

	/* test range interface */
	tmp = srandom(0);
	print				  '5311: tmp = srandom(0)';
	vrfy(random(12345678901234567890) == 0x7fb838a8a0a95046, \
		  '5312: random(12345678901234567890) == 0x7fb838a8a0a95046');
	vrfy(random(216091) == 0x2e767,	  '5313: random(216091) == 0x2e767');
	vrfy(random(100) == 0x33,	  '5314: random(100) == 0x33');
	vrfy(random(-46,46) == -0xc,	  '5315: random(-46,46) == -0xc');
	tmp = srandom(0);
	print				  '5316: tmp = srandom(0)';
	vrfy(random(2^64) == 0x7fb838a8a0a95046, \
		  '5317: random(2^64) == 0x7fb838a8a0a95046');
	vrfy(random(0,2^64) == 0xb9d9d9fb4440f7bb, \
		  '5318: random(0,2^64) == 0xb9d9d9fb4440f7bb');

	/* test different forms of seeding the initial state */
	tmp = srandom(0);
	print				  '5319: tmp = srandom(0)';
	vrfy(srandom() == init,		  '5320: srandom() == init');
	tmp = srandom(0x87e6ec938ff55aa5<<64);
	print	  '5321: tmp = srandom(0x87e6ec938ff55aa5<<64)';
	vrfy(srandom() == init,		  '5322: srandom() == init');
	tmp = srandom(state0);
	print				  '5323: tmp = srandom(state0)';
	vrfy(srandom() == init,		  '5324: srandom() == init');
	tmp = srandom(init);
	print				  '5325: tmp = srandom(init)';
	vrfy(srandom() == init,		  '5326: srandom() == init');
	vrfy(tmp == init,		  '5327: tmp == init');

	/* test the bit length interface */
	tmp = srandom(0);
	print				  '5328: tmp = srandomom(0)';
	vrfy(randombit(64) == 0x7fb838a8a0a95046, \
		  '5329: randombit(64) == 0x7fb838a8a0a95046');
	vrfy(randombit(128) == 0xb9d9d9fb4440f7bbc1a7bd3b4e853fc9, \
		  '5330: randombit(128) == 0xb9d9d9fb4440f7bbc1a7bd3b4e853fc9');
	vrfy(randombit(64) == 0x2d4e1588719986aa, \
		  '5331: randombit(64) == 0x2d4e1588719986aa');
	vrfy(randombit(128) == 0x8d68905434b020ccb849e17a03a5c441, \
		  '5332: randombit(128) == 0x8d68905434b020ccb849e17a03a5c441');
	tmp = srandom(0);
	print				  '5333: tmp = srandom(0)';
	vrfy(randombit(32) == 0x7fb838a8, '5334: randombit(32) == 0x7fb838a8');
	vrfy(randombit(32) == 0xa0a95046, '5335: randombit(32) == 0xa0a95046');
	vrfy(randombit(1) == 0x1,	  '5336: randombit(1) == 0x1');
	vrfy(randombit(5) == 0xe,	  '5337: randombit(5) == 0xe');
	vrfy(randombit(33) == 0xececfda2, '5338: randombit(33) == 0xececfda2');
	vrfy(randombit(25) == 0x40f7bb,	 '5339: randombit(25) == 0x40f7bb');
	vrfy(randombit(2) == 0x3,	  '5340: randombit(2) == 0x3');
	vrfy(randombit(13) == 0xd3,	  '5341: randombit(13) == 0xd3');
	vrfy(randombit(18) == 0x37a76,	  '5342: randombit(18) == 0x37a76');
	vrfy(randombit(8) == 0x9d,	  '5343: randombit(8) == 0x9d');
	vrfy(randombit(9) == 0x14,	  '5344: randombit(9) == 0x14');
	vrfy(randombit(70) == 0x3fc92d4e1588719986, \
		  '5345: randombit(70) == 0x3fc92d4e1588719986');
	vrfy(randombit(123) == 0x5546b4482a1a5810665c24f0bd01d2e, \
		  '5346: randombit(123) == 0x5546b4482a1a5810665c24f0bd01d2e');
	vrfy(randombit(8) == 0x22,	  '5347: randombit(8) == 0x22');
	vrfy(randombit(65) == 0x1d2a104aaf523699, \
		  '5348: randombit(65) == 0x1d2a104aaf523699');
	vrfy(randombit(63) == 0x60e63d498ba690ec, \
		  '5349: randombit(63) == 0x60e63d498ba690ec');
	vrfy(randombit(1) == 0x1,	  '5350: randombit(1) == 0x1');
	vrfy(randombit(2) == 0x3,	  '5351: randombit(2) == 0x3');
	vrfy(randombit(4) == 0x0,	  '5352: randombit(4) == 0x0');
	vrfy(randombit(3) == 0x0,	  '5353: randombit(3) == 0x0');
	state1 = srandom();
	print				  '5354: state1 = srandom()';

	/* test randombit skip interface */
	tmp = srandom(0);
	print				  '5355: tmp = srandom(0)';
	vrfy(randombit(20) == 523139,	  '5356: randombit(20) == 523139');
	vrfy(randombit(20) == 567456,	  '5357: randombit(20) == 567456');
	vrfy(randombit(20) == 693508,	  '5358: randombit(20) == 693508');
	vrfy(randombit(20) == 440793,	  '5359: randombit(20) == 440793');
	tmp = srandom(0);
	print				  '5360: tmp = srandom(0)';
	vrfy(randombit(-20) == 20,	  '5361: randombit(-20) == 20');
	vrfy(randombit(20) == 567456,	  '5362: randombit(20) == 567456');
	vrfy(randombit(-20) == 20,	  '5363: randombit(-20) == 20');
	vrfy(randombit(20) == 440793,	  '5364: randombit(20) == 440793');

	/* test randombit without and arg */
	tmp = srandom(0);
	print				  '5365: tmp = srandom(0)';
	vrfy(randombit() == 0,		  '5366: randombit() == 0');
	vrfy(randombit() == 1,		  '5367: randombit() == 1');
	vrfy(randombit() == 1,		  '5368: randombit() == 1');

	/* test range interface some more */
	tmp = srandom(state1);
	print				  '5369: tmp = srandom(state1)';
	vrfy(random(-46,46) == -0x7,	  '5370: random(-46,46) == -0x7');
	vrfy(random(21701,23209) == 23061,
		'5371: random(21701,23209) == 23061');
	vrfy(random(0x22,0x1d2a104aaf523699) == 0x17c97dfa80bbdf1b,
		'5372: random(0x22,0x1d2a104aaf523699) == 0x17c97dfa80bbdf1b');
	vrfy(random(0x2d4e16aa,0x7fb83046) == 0x48e98d92,
		'5373: random(0x2d4e16aa,0x7fb83046) == 0x48e98d92');
	vrfy(random(-0x2d4986aa,0x7fb83846) == 0x3b3f6c0c,
		'5374: random(-0x2d4986aa,0x7fb83846) == 0x3b3f6c0c');
	vrfy(random(-0x2d9986aa,-0x7fb9504) == -0x235f9ce1,
		'5375: random(-0x2d9986aa,-0x7fb9504) == -0x235f9ce1');


	/* test pre-compiled random states */
	tmp = srandom(init);
	print				  '5376: tmp = srandom(init)';
	state0 = srandom(0,1);
	print				  '5377: state0 = srandom(0,1)';
	vrfy(randombit(123) == 0x4cf8834399f8832d5c1ec35f20095f0, \
		  '5378: randombit(123) == 0x4cf8834399f8832d5c1ec35f20095f0');
	state1 = srandom(123455432112345,1);
	print	  '5379: state1 = srandom(123455432112345,1)';
	vrfy(randombit(123) == 0x437c9618d5a9c07d935b0ff7cef7346, \
		  '5380: randombit(123) == 0x437c9618d5a9c07d935b0ff7cef7346');
	tmp = srandom(0,1);
	print				  '5381: tmp = srandom(0,1)';
	vrfy(randombit(-123) == 123,	  '5382: randombit(-123) == 123');
	vrfy(srandom() == state1,	  '5383: srandom() == state1');
	tmp = srandom(0,2);
	print				  '5384: tmp = srandom(0,2)';
	vrfy(randombit(123) == 0x7d53b2dbfe1edcb07df84f7fe96d5e9, \
		  '5385: randombit(123) == 0x7d53b2dbfe1edcb07df84f7fe96d5e9');
	tmp = srandom(0,3);
	print				  '5386: tmp = srandom(0,3)';
	vrfy(randombit(123) == 0x365cbae1adb9a706816abe3b64c1f2a, \
		  '5387: randombit(123) == 0x365cbae1adb9a706816abe3b64c1f2a');
	tmp = srandom(0,4);
	print				  '5388: tmp = srandom(0,4)';
	vrfy(randombit(123) == 0x63d9621736e59a3a5a8311117a1ef01, \
		  '5389: randombit(123) == 0x63d9621736e59a3a5a8311117a1ef01');
	tmp = srandom(0,5);
	print				  '5390: tmp = srandom(0,5)';
	vrfy(randombit(123) == 0x38d90517d6d532d1efb6eaf26bf927, \
		  '5391: randombit(123) == 0x38d90517d6d532d1efb6eaf26bf927');
	tmp = srandom(0,6);
	print				  '5392: tmp = srandom(0,6)';
	vrfy(randombit(123) == 0x146f2a1ce8cabcc313ab24f73747fbc, \
		  '5393: randombit(123) == 0x146f2a1ce8cabcc313ab24f73747fbc');
	tmp = srandom(0,7);
	print				  '5394: tmp = srandom(0,7)';
	vrfy(randombit(123) == 0x7a4a2b4ed817e5267358ea2979155d8, \
		  '5395: randombit(123) == 0x7a4a2b4ed817e5267358ea2979155d8');
	tmp = srandom(0,8);
	print				  '5396: tmp = srandom(0,8)';
	vrfy(randombit(123) == 0x5f30f211464854a37989cca3a8ecd0a, \
		  '5397: randombit(123) == 0x5f30f211464854a37989cca3a8ecd0a');
	tmp = srandom(0,9);
	print				  '5398: tmp = srandom(0,9)';
	vrfy(randombit(123) == 0x73aa8e572ee77682ae317804ed8d6e5, \
		  '5399: randombit(123) == 0x73aa8e572ee77682ae317804ed8d6e5');
	tmp = srandom(0,10);
	print				  '5400: tmp = srandom(0,10)';
	vrfy(randombit(123) == 0x49c7acca8f461ad2edf4cb7651f18d3, \
		  '5401: randombit(123) == 0x49c7acca8f461ad2edf4cb7651f18d3');
	tmp = srandom(0,11);
	print				  '5402: tmp = srandom(0,11)';
	vrfy(randombit(123) == 0x6042e2169a73140ffab1881df99a0ee, \
		  '5403: randombit(123) == 0x6042e2169a73140ffab1881df99a0ee');
	tmp = srandom(0,12);
	print				  '5404: tmp = srandom(0,12)';
	vrfy(randombit(123) == 0x7b98097947d478611d96f4d7a1cd2af, \
		  '5405: randombit(123) == 0x7b98097947d478611d96f4d7a1cd2af');
	tmp = srandom(0,13);
	print				  '5406: tmp = srandom(0,13)';
	vrfy(randombit(123) == 0x12324fd76d7a4a5a979765be2d57cfa, \
		  '5407: randombit(123) == 0x12324fd76d7a4a5a979765be2d57cfa');
	tmp = srandom(0,14);
	print				  '5408: tmp = srandom(0,14)';
	vrfy(randombit(123) == 0x377ff9ef04ee24887984995f91489a3, \
		  '5409: randombit(123) == 0x377ff9ef04ee24887984995f91489a3');
	tmp = srandom(0,15);
	print				  '5410: tmp = srandom(0,15)';
	vrfy(randombit(123) == 0x7db2b6245c5a24a1a52f74c8f828c6f, \
		  '5411: randombit(123) == 0x7db2b6245c5a24a1a52f74c8f828c6f');
	tmp = srandom(0,16);
	print				  '5412: tmp = srandom(0,16)';
	vrfy(randombit(123) == 0x5958e6cc460c28a5e741706fd442f12, \
		  '5413: randombit(123) == 0x5958e6cc460c28a5e741706fd442f12');
	tmp = srandom(0,17);
	print				  '5414: tmp = srandom(0,17)';
	vrfy(randombit(123) == 0x68c40ccf3805b2734d0d2881ca268d, \
		  '5415: randombit(123) == 0x68c40ccf3805b2734d0d2881ca268d');
	tmp = srandom(0,18);
	print				  '5416: tmp = srandom(0,18)';
	vrfy(randombit(123) == 0x4afc6cd3b9e14dadc5b75c6a81602e5, \
		  '5417: randombit(123) == 0x4afc6cd3b9e14dadc5b75c6a81602e5');
	tmp = srandom(0,19);
	print				  '5418: tmp = srandom(0,19)';
	vrfy(randombit(123) == 0x3ea4d30abf7da6596d2425e0a9a6348, \
		  '5419: randombit(123) == 0x3ea4d30abf7da6596d2425e0a9a6348');
	tmp = srandom(0,20);
	print				  '5420: tmp = srandom(0,20)';
	vrfy(randombit(123) == 0x77f848c70d4622ed41956eceb3f15f6, \
		  '5421: randombit(123) == 0x77f848c70d4622ed41956eceb3f15f6');
	vrfy(randombit(123) == 0x5bfa034925acaf7ad5ba5d8f7f32369, \
		  '5422: randombit(123) == 0x5bfa034925acaf7ad5ba5d8f7f32369');
	vrfy(randombit(123) == 0x761100a4cecbdac8c8d539dee0e278e, \
		  '5423: randombit(123) == 0x761100a4cecbdac8c8d539dee0e278e');


	tmp = srandom(7^23+19,2);
	print				  '5424: tmp = srandom(7^23+19,2)';
	vrfy(randombit(123) == 0x89b7ec9413e8af84a0c64ffc64d5a8, \
		  '5425: randombit(123) == 0x89b7ec9413e8af84a0c64ffc64d5a8');
	tmp = srandom(7^23+19,3);
	print				  '5426: tmp = srandom(7^23+19,3)';
	vrfy(randombit(123) == 0x7a2b8a6ca93a29deb1c3a674a30bf26, \
		  '5427: randombit(123) == 0x7a2b8a6ca93a29deb1c3a674a30bf26');
	tmp = srandom(7^23+19,4);
	print				  '5428: tmp = srandom(7^23+19,4)';
	vrfy(randombit(123) == 0x5425c6614dffcc0f376de4e9355c7df, \
		  '5429: randombit(123) == 0x5425c6614dffcc0f376de4e9355c7df');
	tmp = srandom(7^23+19,5);
	print				  '5430: tmp = srandom(7^23+19,5)';
	vrfy(randombit(123) == 0x70fca502499fa3717e346df5438886d, \
		  '5431: randombit(123) == 0x70fca502499fa3717e346df5438886d');
	tmp = srandom(7^23+19,6);
	print				  '5432: tmp = srandom(7^23+19,6)';
	vrfy(randombit(123) == 0x6ff886ac0918ad503290544af2cbd03, \
		  '5433: randombit(123) == 0x6ff886ac0918ad503290544af2cbd03');
	tmp = srandom(7^23+19,7);
	print				  '5434: tmp = srandom(7^23+19,7)';
	vrfy(randombit(123) == 0x5747d8c33d6d6dc53357779dffcc430, \
		  '5435: randombit(123) == 0x5747d8c33d6d6dc53357779dffcc430');
	tmp = srandom(7^23+19,8);
	print				  '5436: tmp = srandom(7^23+19,8)';
	vrfy(randombit(123) == 0x12769f65324d5e7986120b0caf071ad, \
		  '5437: randombit(123) == 0x12769f65324d5e7986120b0caf071ad');
	tmp = srandom(7^23+19,9);
	print				  '5438: tmp = srandom(7^23+19,9)';
	vrfy(randombit(123) == 0x3f94d3585b986539158f6ccd97d261e, \
		  '5439: randombit(123) == 0x3f94d3585b986539158f6ccd97d261e');
	tmp = srandom(7^23+19,10);
	print				  '5440: tmp = srandom(7^23+19,10)';
	vrfy(randombit(123) == 0x12874c359fffc6c0eda2aebfea97c71, \
		  '5441: randombit(123) == 0x12874c359fffc6c0eda2aebfea97c71');
	tmp = srandom(7^23+19,11);
	print				  '5442: tmp = srandom(7^23+19,11)';
	vrfy(randombit(123) == 0x7e0480a70c6f32f6594db8fd58ada7, \
		  '5443: randombit(123) == 0x7e0480a70c6f32f6594db8fd58ada7');
	tmp = srandom(7^23+19,12);
	print				  '5444: tmp = srandom(7^23+19,12)';
	vrfy(randombit(123) == 0x7f900aa8c7b9dacb6bf4ca0f5f81cb8, \
		  '5445: randombit(123) == 0x7f900aa8c7b9dacb6bf4ca0f5f81cb8');
	tmp = srandom(7^23+19,13);
	print				  '5446: tmp = srandom(7^23+19,13)';
	vrfy(randombit(123) == 0x39311c5aa41e42bb5d7807bdb60aecc, \
		  '5447: randombit(123) == 0x39311c5aa41e42bb5d7807bdb60aecc');
	tmp = srandom(7^23+19,14);
	print				  '5448: tmp = srandom(7^23+19,14)';
	vrfy(randombit(123) == 0x508bc8c5bd4555262b7ecd32a1ecd8e, \
		  '5449: randombit(123) == 0x508bc8c5bd4555262b7ecd32a1ecd8e');
	tmp = srandom(7^23+19,15);
	print				  '5450: tmp = srandom(7^23+19,15)';
	vrfy(randombit(123) == 0x442d2076b8d58d3815841180e8401b6, \
		  '5451: randombit(123) == 0x442d2076b8d58d3815841180e8401b6');
	tmp = srandom(7^23+19,16);
	print				  '5452: tmp = srandom(7^23+19,16)';
	vrfy(randombit(123) == 0x38db53974de9d3eea82a6ba35d2dc53, \
		  '5453: randombit(123) == 0x38db53974de9d3eea82a6ba35d2dc53');
	tmp = srandom(7^23+19,17);
	print				  '5454: tmp = srandom(7^23+19,17)';
	vrfy(randombit(123) == 0x42c1d9d86c9c67acb518ee008ce8f38, \
		  '5455: randombit(123) == 0x42c1d9d86c9c67acb518ee008ce8f38');
	tmp = srandom(7^23+19,18);
	print				  '5456: tmp = srandom(7^23+19,18)';
	vrfy(randombit(123) == 0x10dc81d7ef0a7aeb4aea1d4ac1fac2a, \
		  '5457: randombit(123) == 0x10dc81d7ef0a7aeb4aea1d4ac1fac2a');
	tmp = srandom(7^23+19,19);
	print				  '5458: tmp = srandom(7^23+19,19)';
	vrfy(randombit(123) == 0x469f8d91b643e0bcc4b5d5c2fe61cfb, \
		  '5459: randombit(123) == 0x469f8d91b643e0bcc4b5d5c2fe61cfb');
	tmp = srandom(7^23+19,20);
	print				  '5460: tmp = srandom(7^23+19,20)';
	vrfy(randombit(123) == 0x7f056e87cfcbe04a072e17502ef38f5, \
		  '5461: randombit(123) == 0x7f056e87cfcbe04a072e17502ef38f5');
	vrfy(randombit(123) == 0x5d10d7665e56dee0ec5ea7d918ba073, \
		  '5462: randombit(123) == 0x5d10d7665e56dee0ec5ea7d918ba073');
	vrfy(randombit(123) == 0x2058f802dd42b3aee4e734eacc13057, \
		  '5463: randombit(123) == 0x2058f802dd42b3aee4e734eacc13057');

	/* test seed() as best as we can */
	vrfy(seed() >= 0,		  '5464: seed() >= 0');
	vrfy(seed() < 2^64,		  '5465: seed() < 2^64');
	vrfy(israndom(srandom(seed())),	  '5466: israndom(srandom(seed()))');

	/* verify random(10,11) double bug fix */
	vrfy(random(10,11) == 10,	  '5467: random(10,11) == 10');
	vrfy(random(10,11) == 10,	  '5468: random(10,11) == 10');
	vrfy(random(10,11) == 10,	  '5469: random(10,11) == 10');
	vrfy(random(0,1) == 0,		  '5470: random(0,1) == 0');
	vrfy(random(0,1) == 0,		  '5471: random(0,1) == 0');

	print '5472: Ending test_random';
}
print '137: parsed test_random()';


/*
 * test_newsyn - test new command completion syntax and scope rules
 */
for (s5500 = 0, i = 0; i < 5; i++) s5500 += i;
print "138: for (s5500 = 0, i = 0; i < 5; i++) s5500 += i;";
vrfy(s5500 == 10,		'139: s5500 == 10');
vrfy(i == 5,		'140: i == 5');
for (s5500 = 0, i = 0; i < 9; i++) {
	s5500 += i;
}
print "141: for (s5500 = 0, i = 0; i < 9; i++) { s5500 += i; }";
vrfy(s5500 == 36,		'142: s5500 == 36');
vrfy(i == 9,		'143: i == 9');
{
	local i;
	for (s5500 = 0, i = 0; i < 10; i++)
		s5500 += i;
	vrfy(s5500 == 45,	'144: s5500 == 45');
	vrfy(i == 10,	'145: i == 10');
}
print "146: { local i; for (s5500 = 0, i = 0; i < 10; i++) s5500 += i; ... }";
vrfy(s5500 == 45,		'147: s5500 == 45');
vrfy(i == 9,		'148: i == 9');
/**/
define test_newsyn()
{
	local i;	/* loop counter */

	print '5500: Beginning test_newsyn';

	/*
	 * check basic for loop completion and scoping
	 */
	for (s5500 = 0, i = 0; i < 5; i++)
		s5500 += i;
	print "5501: for (s5500 = 0, i = 0; i < 5; i++) s5500 += i;";
	vrfy(s5500 == 10,			  '5502: s5500 == 10');
	vrfy(i == 5,			  '5503: i == 5');
	/**/
	for (s5500 = 0, i = 0; i < 6; i++)
	{
		s5500 += i;
	}
	print "5504: for (s5500 = 0, i = 0; i < 6; i++) { s5500 += i; }";
	vrfy(s5500 == 15,			  '5505: s5500 == 15');
	vrfy(i == 6,			  '5506: i == 6');
	/**/
	for (s5500 = 0, i = 0; i < 3; i++) {
		s5500 += i;
	}
	print "5507: for (s5500 = 0, i = 0; i < 3; i++) { s5500 += i; }";
	vrfy(s5500 == 3,			  '5508: s5500 == 3');
	vrfy(i == 3,			  '5509: i == 3');
	/**/
	{
		for (s5500 = 0, i = 0; i < 11; i++)
			s5500 += i;
		vrfy(s5500 == 55,		  '5510: s5500 == 45');
		vrfy(i == 11,		  '5511: i == 11');
	}
	print "5512: { local i; for (s5500 = 0, i = 0; i < 10; i++) s5500 += i; ... }";
	vrfy(s5500 == 55,			  '5513: s5500 == 55');
	vrfy(i == 11,			  '5514: i == 11');

	/*
	 * test completion of while loops
	 */
	i = 0;
	print				  '5515: i = 0';
	s5500 = 0;
	print				  '5516: s5500 = 0';
	while (++i < 4)
		s5500 += i;
	print "5517: while (++i < 4) s5500 += i;";
	vrfy(s5500 == 6,			  '5518: s5500 == 6');
	vrfy(i == 4,			  '5519: i == 4');
	/**/
	i = 0;
	print				  '5520: i = 0';
	s5500 = 0;
	print				  '5521: s5500 = 0';
	while (++i < 7)
	{
		s5500 += i;
	}
	print "5522: while (++i < 7) { s5500 += i; }";
	vrfy(s5500 == 21,			  '5523: s5500 == 21');
	vrfy(i == 7,			  '5524: i == 7');
	/**/
	i = 0;
	print				  '5525: i = 0';
	s5500 = 0;
	print				  '5526: s5500 = 0';
	while (++i < 8) {
		s5500 += i;
	}
	print "5527: while (++i < 8) { s5500 += i; }";
	vrfy(s5500 == 28,			  '5528: s5500 == 28');
	vrfy(i == 8,			  '5529: i == 8');

	/*
	 * test completion of do-while loops
	 */
	i = 0;
	print				  '5530: i = 0';
	s5500 = 0;
	print				  '5531: s5500 = 0';
	do
		s5500 += i;
	while (++i < 12);
	print "5532: do s5500 += i; while (++i < 12);";
	vrfy(s5500 == 66,			  '5533: s5500 == 66');
	vrfy(i == 12,			  '5534: i == 12');
	/**/
	i = 0;
	print				  '5535: i = 0';
	s5500 = 0;
	print				  '5536: s5500 = 0';
	do {
		s5500 += i;
	} while (++i < 14)
	print "5537: do { s5500 += i; } while (++i < 14);";
	vrfy(s5500 == 91,			  '5538: s5500 == 91');
	vrfy(i == 14,			  '5539: i == 14');
	/**/
	i = 0;
	print				  '5540: i = 0';
	s5500 = 0;
	print				  '5541: s5500 = 0';
	do
	{
		s5500 += i;
	}
	while (++i < 13)
	;
	print "5542: do { s5500 += i; } while (++i < 13);";
	vrfy(s5500 == 78,			  '5543: s5500 == 78');
	vrfy(i == 13,			  '5544: i == 13');

	/*
	 * test the completion of switch
	 */
	switch (i) {
	case 12: prob("switch showed i was 12 instead of 13"); break;
	case 13:
		vrfy(i == 13,		  '5545: i == 13');
		break;
	default:
		prob("switch showed i was something other than 13");
		break;
	}
	switch
	(
	i
	)
	{
	case
	1
	:
	prob(
	"switch showed i was 1 instead of 13"
	)
	;
	break
	;
	case
	2
	:
	prob(
	"switch showed i was 2 instead of 13"
	)
	;
	break
	;
	default
	:
	vrfy
	(
	i
	==
	13
	,
	'5546: i == 13'
	)
	;
	}

	print '5547: Ending test_newsyn';
}
print '149: parsed test_newsyn()';
vrfy(s5500 == 45,	'150: s5500 == 45');
vrfy(i == 9,		'151: i == 9');


/*
 * test_commaeq - test changes to , and =
 */
obj xx5600 {} xx5600;
print '152: obj xx5600 {} xx5600';
define xx5600_print() = printf("xx");
print '153: xx5600_print() = printf("xx")';
/**/
define test_commaeq()
{
	local i;
	local A, B, C, D;
	local a5600 = 0, b5600 = 0;
	obj xy5600 {x, y};

	/*
	 * Calculations with i
	 */
	print '5600: Beginning test_commaeq';
	i = 5;
	print				  '5601: i = 5';
	vrfy(i == 5,			  '5602: i == 5');
	i += 2 *= 3 -= 1;
	print				  '5603: i += 2 *= 3 -= 1';
	vrfy(i == 20,			  '5604: i == 20');
	++i /= 7;
	print				  '5607: ++i /= 7';
	vrfy(i == 3,			  '5608: i == 3');

	/*
	 * xx5600 object type
	 */
	mat A[3] = {1,2,xx5600};
	print				  '5609: mat A[3] = {1,2,xx5600}';
	vrfy(A[2] == xx5600,		  '5610: A[2] == xx5600');
	vrfy(strprintf("%d", xx5600) == "xx",
			'5611: strprintf("%d", xx5600) == "xx"');

	/*
	 * xy5600 object type
	 */
	obj xy5600 A = {1, 2} = {3, 4};
	print		'5612: obj xy5600 A = {1, 2} = {3, 4}';
	vrfy(A.x == 3,			  '5613: A.x == 3');
	vrfy(A.y == 4,			  '5614: A.y == 4');
	obj xy5600 B = {A,A};
	print		'5613: obj xy5600 B = {A,A}';
	vrfy(B.x.x == 3,		  '5615: B.x.x == 3');
	vrfy(B.y.y == 4,		  '5616: B.y.y == 4');
	obj xy5600 C;
	print				  '5617: obj xy5600 C';
	C = {1, 2} = {C, C};
	print				  '5618: C = {1, 2} = {C, C}';
	vrfy(C.x.x == 1,		  '5619: C.x.x == 1');
	vrfy(C.y.x.y == 2,		  '5620: C.y.x.y == 2');
	D = 7;
	print				  '5621: D = 7';
	obj xy5600 D = {1,2} = {D,D};
	print				  '5622: obj xy5600 D = {1,2} = {D,D}';
	vrfy(D.x == 7,			  '5623: D.x == 7');
	vrfy(D.y == 7,			  '5624: D.y == 7');

	/*
	 * matrix assignment
	 */
	mat A[3] = {1,2,3}, mat B[2] = {1,2};
	print		'5625: mat A[3] = {1,2,3}, mat B[2] = {1,2}';
	vrfy(A[0] == 1,			  '5626: A[0] == 1');
	vrfy(B[1] == 2,			  '5627: B[1] == 2');

	/*
	 * misc = and , expressions
	 */
	vrfy(((a5600 = 2, b5600) = 3) && a5600 + b5600 == 5,
		'5628: ((a5600 = 2, b5600) = 3) && a5600 + b5600 == 5');
	vrfy((2 ? a5600 : b5600 = 4) && a5600 == 4,
		'5629: (2 ? a5600 : b5600 = 4) && a5600 == 4');
	vrfy((0 ? a5600 : b5600 = 5) && b5600 == 5,
		'5630: (0 ? a5600 : b5600 = 5) && b5600 == 5');
	vrfy((a5600 || b5600 = 6) && a5600 == 6 && b5600 == 5,
		'5631: (a5600 || b5600 = 6) && a5600 == 6 && b5600 == 5');
	vrfy((a5600 && b5600 = 7) && a5600 == 6 && b5600 == 7,
		'5632: (a5600 && b5600 = 7) && a5600 == 6 && b5600 == 7');

	print '5633: Ending test_commaeq';
}
print '155: parsed test_commaeq()';


/*
 * test_size - test what we can about sizes
 *
 * Since sizeof() and memsize() deal with machine specific sizes and
 * compiler structure layout issues, we cannot just determine if
 * these builtin values return a specific value.
 */
define test_size()
{
	local z;	/* test integer values */
	local q;	/* test rational values */
	local c;	/* test complex values */
	local m;	/* test matrix */
	local l;	/* test list */
	local a;	/* test association */

	print '5700: Beginning test_size';

	/*
	 * 0, -1 and 1 values are reported as 0 sizeof
	 */
	vrfy(sizeof(0) == 0,		  '5701: sizeof(0) == 0');
	vrfy(sizeof(1) == 0,		  '5702: sizeof(1) == 0');
	vrfy(sizeof(-1) == 0,		  '5703: sizeof(-1) == 0');
	z = 0;
	print				  '5704: z = 0';
	vrfy(sizeof(z) == 0,		  '5705: sizeof(z) == 0');
	z = 1;
	print				  '5706: z = 1';
	vrfy(sizeof(z) == 0,		  '5707: sizeof(z) == 0');
	z = -1;
	print				  '5708: z = -1';
	vrfy(sizeof(z) == 0,		  '5709: sizeof(z) == 0');

	/*
	 * non-integer rationals are larger than integers
	 */
	q = 13/2;
	print				  '5710: q = 13/2';
	vrfy(sizeof(13)*2 == sizeof(q),	  '5711: sizeof(13)*2 == sizeof(q)');
	q = 13;
	print				  '5712: q = 13';
	vrfy(sizeof(13) == sizeof(q),	  '5713: sizeof(13) == sizeof(q)');
	q = (17^139 + 674) / (17^139 + 686);
	print		'5714: q = (17^139 + 674) / (17^139 + 686)';
	vrfy(sizeof(17^139 + 674)*2 == sizeof(q),
			'5715: sizeof(17^139 + 674)*2 == sizeof(q)');

	/*
	 * recipricals are the same size of their integer inverses
	 */
	q = 1/13;
	print				  '5716: q = 1/13';
	vrfy(sizeof(13) == sizeof(q),	  '5717: sizeof(13) == sizeof(q)');
	q = 1/(17^139 + 674);
	print				  '5718: q = 1/(17^139 + 674)';
	vrfy(sizeof(17^139 + 674) == sizeof(q),
			'5717: sizeof(17^139 + 674) == sizeof(q)');

	/*
	 * negative values are the same size as positive values
	 */
	vrfy(sizeof(17^139 + 674) == sizeof(-q),
			'5718: sizeof(17^139 + 674) == sizeof(-q)');
	vrfy(sizeof(-(17^139 + 674)) == sizeof(-q),
			'5719: sizeof(-(17^139 + 674)) == sizeof(-q)');
	q = 1/-13;
	print				  '5720: q = 1/-13';
	vrfy(sizeof(13) == sizeof(q),	  '5721: sizeof(13) == sizeof(q)');

	/*
	 * complex values with a real or imaginary part of 0, 1 or -1
	 * are the same size as rationals
	 */
	c = 0 + 4i;
	print				  '5722: c = 0 + 4i';
	vrfy(sizeof(3) == sizeof(c),	  '5723: sizeof(3) == sizeof(c)');
	c = 3 + 0i;
	print				  '5724: c = 3 + 0i';
	vrfy(sizeof(3) == sizeof(c),	  '5725: sizeof(3) == sizeof(c)');
	c = 1 + 4i;
	print				  '5726: c = 1 + 4i';
	vrfy(sizeof(3) == sizeof(c),	  '5727: sizeof(3) == sizeof(c)');
	c = 3 + 1i;
	print				  '5728: c = 3 + 1i';
	vrfy(sizeof(3) == sizeof(c),	  '5729: sizeof(3) == sizeof(c)');
	c = -1 + 4i;
	print				  '5730: c = -1 + 4i';
	vrfy(sizeof(3) == sizeof(c),	  '5731: sizeof(3) == sizeof(c)');
	c = 3 + -1i;
	print				  '5732: c = 3 + -1i';
	vrfy(sizeof(3) == sizeof(c),	  '5733: sizeof(3) == sizeof(c)');

	/*
	 * general complex values are twice the size as rationals
	 */
	c = 3 + 4i;
	print				  '5734: c = 3 + 4i';
	vrfy(sizeof(3)*2 == sizeof(c),	  '5735: sizeof(3)*2 == sizeof(c)');
	z = 17^139 + 686;
	print				  '5736: z = 17^139 + 686';
	c = z + z*1i;
	print				  '5737: c = z + z*1i';
	vrfy(sizeof(z)*2 == sizeof(c),	  '5738: sizeof(z)*2 == sizeof(c)');
	q = 1/(17^139 + 674);
	print				  '5739: q = 1/(17^139 + 674)';
	c = q + q*1i;
	print				  '5740: c = q + q*1i';
	vrfy(sizeof(q)*2 == sizeof(c),	  '5741: sizeof(q)*2 == sizeof(c)');
	c = (z*q) + (1/(z*q))*1i;
	print				  '5742: c = (z*q) + (1/(z*q))*1i';
	vrfy(sizeof(z*q)*2 == sizeof(c),  '5743: sizeof(z*q)*2 == sizeof(c)');
	vrfy(sizeof(z)*4 == sizeof(c),	  '5744: sizeof(z)*4 == sizeof(c)');
	vrfy(sizeof(q)*4 == sizeof(c),	  '5745: sizeof(q)*4 == sizeof(c)');

	/*
	 * size of numeric values is always 1
	 */
	vrfy(size(0) == 1,		  '5746: size(0) == 1');
	vrfy(size(1) == 1,		  '5747: size(1) == 1');
	vrfy(size(13^10) == 1,		  '5748: size(13^10) == 1');
	vrfy(size(z) == 1,		  '5749: size(z) == 1');
	vrfy(size(q) == 1,		  '5750: size(q) == 1');
	vrfy(size(c) == 1,		  '5751: size(c) == 1');

	/*
	 * size of a matrix is the sum of the sizes of the elements
	 * sizeof of a matrix is the sum of the sizeofs of the elements
	 */
	mat m[] = {z,q,c};
	print				  '5752: mat m[] = {z,q,c}';
	vrfy(size(m) == size(z)+size(q)+size(c),
			'5753: size(m) == size(z)+size(q)+size(c)');
	vrfy(sizeof(m) == sizeof(z)+sizeof(q)+sizeof(c),
			'5754: sizeof(m) == sizeof(z)+sizeof(q)+sizeof(c)');

	/*
	 * size of a list is the number of elements
	 * sizeof of a list is the sum of the sizeof's of the elements
	 */
	l = list(z,q,c,m);
	print				  '5755: list(z,q,c,m)';
	vrfy(size(l) == 4,		  '5756: size(l) == 4');
	vrfy(sizeof(l) == 2*sizeof(m),	  '5757: sizeof(l) == 2*sizeof(m)');

	/*
	 * size of an assoc is the number of elements
	 * sizeof of an assoc is the sum of the sizeof's of the elements
	 */
	a = assoc();
	print				  '5758: a = assoc()';
	a["z"] = z+1;
	print				  '5759: a["z"] = z+1';
	a["q"] = q+2;
	print				  '5760: a["q"] = q+2';
	a["c"] = c+3;
	print				  '5761: a["c"] = c+3';
	a[m] = m;
	print				  '5762: a[m] = m';
	a[l] = l;
	print				  '5763: a[l] = l';
	vrfy(size(a) == 5,		  '5764: size(a) == 5');
	vrfy(sizeof(a) == 25*sizeof(z),	  '5765: sizeof(a) == 25*sizeof(z)');

	/*
	 * about all we can say about memsize is that it will always be
	 * larger than sizeof
	 */
	vrfy(sizeof(z) < memsize(z),	  '5766: sizeof(z) < memsize(z)');
	vrfy(sizeof(q) < memsize(q),	  '5767: sizeof(q) < memsize(q)');
	vrfy(sizeof(c) < memsize(c),	  '5768: sizeof(c) < memsize(c)');
	vrfy(sizeof(m) < memsize(m),	  '5769: sizeof(m) < memsize(m)');
	vrfy(sizeof(l) < memsize(l),	  '5770: sizeof(l) < memsize(l)');
	vrfy(sizeof(a) < memsize(a),	  '5771: sizeof(a) < memsize(a)');

	print '5772: Ending test_size';
}
print '156: parsed test_size()';


/*
 * test_assign - test assignment of constants and variables
 */
global X5800, Y5800;	/* X5800, Y5800 for "variables" */
print '158: global X5800, Y5800';
obj xy5800 {x, y};
print '159: obj xy5800 {x, y}';
/**/
define test_assign(base, work)
{
	print base: ': Beginning test_assign';

	/*
	 * value assignments
	 */
	A = base+1;
	print				  base+1: ': A = base+1';
	B = base+2;
	print				  base+2: ': B = base+2';
	X5800 = base+3;
	print				  base+3: ': X5800 = base+3';
	Y5800 = base+4;
	print				  base+4: ': Y5800 = base+4';
	obj xy5800 A={1,2}, obj xy5800 B={3,4};
	print base+5: ': obj xy5800 A={1,2}, obj xy5800 B={3,4}';

	/*
	 * test assignment
	 */
	X5800 = A;
	print				  base+6: ': X5800 = A';
	if (work) {
		vrfy(X5800 == A,	  strprintf('%d: X5800 == A', base+7));
		X5800 = Y5800 = B;
		print			  base+8: ': X5800 = Y5800 = B';
	} else {
		vrfy(X5800 == B,	  strprintf('%d: X5800 == B', base+7));
		X5800 = Y5800 = A;
		print			  base+8: ': X5800 = Y5800 = A';
	}
	vrfy(X5800 == B,		  strprintf('%d: X5800 == B', base+9));
	vrfy(Y5800 == B,		  strprintf('%d: Y5800 == B', base+10));

	print base+11: ': Ending test_assign';
}
print '160: test_assign()';


/*
 * test_is - test is functions
 */
vrfy(isobjtype("xy5900") == 0,	  '161: isobjtype("xy5900") == 0');
obj xy5900 {x, y};
print				  '162: obj xy5900 {x, y}';
vrfy(isobjtype("xy5900") == 1,	  '163: isobjtype("xy5900") == 1');
/**/
vrfy(isdefined("fun5900") == 0,	  '164: isdefined("fun5900") == 0');
define fun5900() { return 1; };
print				  '165: define fun5900() { return 1; }';
vrfy(isdefined("fun5900") == 2,	  '166: isdefined("fun5900") == 2');
undefine fun5900;
vrfy(isdefined("fun5900") == 0,	  '167: isdefined("fun5900") == 0');
/**/
define test_is()
{
	local loc;	/* unassigned local variable */
	local a;	/* assoc */
	local ofd;	/* open file desriptor */
	local cfd;	/* closed file descriptor */
	local blk;	/* unnamed block */
	local nblk;	/* named block */
	local cfg;	/* config state */
	local serr;	/* system value */
	local nerr;	/* new error value */
	local odd;	/* odd integer */
	local even;	/* even integer that is 10 times odd */
	local hash;	/* sha1 hash value */
	local id;	/* identity matrix */
	local list;	/* list value */
	local matrix;	/* non-identity matrix */
	local nul;	/* null value */
	local object;	/* object */
	local rand;	/* rand seed */
	local random;	/* random seed */
	local real;	/* real non-intger value */
	local prime;	/* odd prime */
	local square;	/* square of an odd prime */
	local string;	/* string */
	local com;	/* complex value */
	local rndint;	/* a random integer */
	local rndexp;	/* a random exponent */
	local rndval;	/* rndint ^ rndexp */
	local i;	/* integer value */
	local ok;	/* 1 ==> issq() tests were OK, 0 ==> failure */

	print '5900: Beginning test_is';

	/*
	 * setup values
	 */
	a = assoc();
	print				  '5901: a = assoc()';
	if (config("windows")) {
	    ofd = fopen("NUL:", "rb");
	    print			  '5902: ofd = fopen("NUL:", "rb")';
	    cfd = fopen("NUL:", "rb");
	    print			  '5903: cfd = fopen("NUL:", "rb")';
	} else {
	    ofd = fopen("/dev/null","rb");
	    print			  '5902: ofd = fopen("/dev/null","rb")';
	    cfd = fopen("/dev/null","rb");
	    print			  '5903: cfd = fopen("/dev/null","rb")';
	}
	fclose(cfd);
	print				  '5904: fclose(cfd)';
	blk = blk();
	print				  '5905: blk = blk()';
	nblk = blk("blk5900");
	print				  '5906: nblk = blk("blk5900")';
	cfg = config("all");
	print				  '5907: cfg = config("all")';
	ecnt += 2;
	print				  '5908: ecnt += 2';
	serr = error(1);
	print				  '5909: serr = error(1)';
	nerr = newerror("curds");
	print				  '5910: nerr = newerror("curds")';
	odd = 23209;
	print				  '5911: odd = 23209';
	even = odd*10;
	print				  '5912: even = odd*10';
	hash = sha1();
	print				  '5913: hash = sha1()';
	mat id[3,3] = {1,0,0,0,1,0,0,0,1};
	print				  '5914: id[3,3] = {1,0,0,0,1,0,0,0,1}';
	list = list(2,3,4);
	print				  '5915: list = list(2,3,4)';
	mat matrix[2];
	print				  '5916: mat matrix[2]';
	nul = null();
	print				  '5917: nul = null()';
	obj xy5900 object;
	print				  '5918: obj xy5900 object';
	rand = srand(0);
	print				  '5919: rand = srand(0)';
	random = srandom(0);
	print				  '5920: random = srandom(0)';
	real = 345.23045897;
	print				  '5921: real = 345.23045897';
	prime = 3217;
	print				  '5922: prime = 3217';
	square = prime^2;
	print				  '5923: square = prime^2';
	string = "a string";
	print				  '5924: string = "a string"';
	com = 3+4i;
	print				  '5925: com = 3+4i';

	print				  '5926: test unused';
	print				  '5927: test unused';
	print				  '5928: test unused';
	print				  '5929: test unused';

	/*
	 * test isassoc
	 */
	vrfy(isassoc(loc) == 0,		  '5930: isassoc(loc) == 0');
	vrfy(isassoc(a) == 1,		  '5931: isassoc(a) == 1');
	vrfy(isassoc(ofd) == 0,		  '5932: isassoc(ofd) == 0');
	vrfy(isassoc(cfd) == 0,		  '5933: isassoc(cfd) == 0');
	vrfy(isassoc(blk) == 0,		  '5934: isassoc(blk) == 0');
	vrfy(isassoc(nblk) == 0,	  '5935: isassoc(nblk) == 0');
	vrfy(isassoc(cfg) == 0,		  '5936: isassoc(cfg) == 0');
	vrfy(isassoc(serr) == 0,	  '5937: isassoc(serr) == 0');
	vrfy(isassoc(nerr) == 0,	  '5938: isassoc(nerr) == 0');
	vrfy(isassoc(odd) == 0,		  '5939: isassoc(odd) == 0');
	vrfy(isassoc(even) == 0,	  '5940: isassoc(even) == 0');
	vrfy(isassoc(hash) == 0,	  '5941: isassoc(hash) == 0');
	vrfy(isassoc(id) == 0,		  '5942: isassoc(id) == 0');
	vrfy(isassoc(list) == 0,	  '5943: isassoc(list) == 0');
	vrfy(isassoc(matrix) == 0,	  '5944: isassoc(matrix) == 0');
	vrfy(isassoc(nul) == 0,		  '5945: isassoc(nul) == 0');
	vrfy(isassoc(object) == 0,	  '5946: isassoc(object) == 0');
	vrfy(isassoc(rand) == 0,	  '5947: isassoc(rand) == 0');
	vrfy(isassoc(random) == 0,	  '5948: isassoc(random) == 0');
	vrfy(isassoc(real) == 0,	  '5949: isassoc(real) == 0');
	vrfy(isassoc(prime) == 0,	  '5950: isassoc(prime) == 0');
	vrfy(isassoc(square) == 0,	  '5951: isassoc(square) == 0');
	vrfy(isassoc(string) == 0,	  '5952: isassoc(string) == 0');
	vrfy(isassoc(com) == 0,		  '5953: isassoc(com) == 0');
	print				  '5954: test unused';
	print				  '5955: test unused';
	print				  '5955: test unused';
	print				  '5956: test unused';
	print				  '5957: test unused';
	print				  '5958: test unused';
	print				  '5959: test unused';

	/*
	 * test isatty
	 */
	vrfy(isatty(loc) == 0,		  '5960: isatty(loc) == 0');
	vrfy(isatty(a) == 0,		  '5961: isatty(a) == 0');
	vrfy(isatty(ofd) == 0,		  '5962: isatty(ofd) == 0');
	vrfy(isatty(cfd) == 0,		  '5963: isatty(cfd) == 0');
	vrfy(isatty(blk) == 0,		  '5964: isatty(blk) == 0');
	vrfy(isatty(nblk) == 0,		  '5965: isatty(nblk) == 0');
	vrfy(isatty(cfg) == 0,		  '5966: isatty(cfg) == 0');
	vrfy(isatty(serr) == 0,		  '5967: isatty(serr) == 0');
	vrfy(isatty(nerr) == 0,		  '5968: isatty(nerr) == 0');
	vrfy(isatty(odd) == 0,		  '5969: isatty(odd) == 0');
	vrfy(isatty(even) == 0,		  '5970: isatty(even) == 0');
	vrfy(isatty(hash) == 0,		  '5971: isatty(hash) == 0');
	vrfy(isatty(id) == 0,		  '5972: isatty(id) == 0');
	vrfy(isatty(list) == 0,		  '5973: isatty(list) == 0');
	vrfy(isatty(matrix) == 0,	  '5974: isatty(matrix) == 0');
	vrfy(isatty(nul) == 0,		  '5975: isatty(nul) == 0');
	vrfy(isatty(object) == 0,	  '5976: isatty(object) == 0');
	vrfy(isatty(rand) == 0,		  '5977: isatty(rand) == 0');
	vrfy(isatty(random) == 0,	  '5978: isatty(random) == 0');
	vrfy(isatty(real) == 0,		  '5979: isatty(real) == 0');
	vrfy(isatty(prime) == 0,	  '5980: isatty(prime) == 0');
	vrfy(isatty(square) == 0,	  '5981: isatty(square) == 0');
	vrfy(isatty(string) == 0,	  '5982: isatty(string) == 0');
	vrfy(isatty(com) == 0,		  '5983: isatty(com) == 0');
	print		'5984: test disabled due to stdin dependency';
	/* if we pipe to awk (for make chk), stdout and stderr are not ttys */
	print				  '5985: test unused';
	print				  '5986: test unused';
	vrfy(isatty(files(3)) == 0,	  '5987: isatty(files(3)) == 0');
	print				  '5988: test unused';
	print				  '5989: test unused';

	/*
	 * test isblk
	 */
	vrfy(isblk(loc) == 0,		  '5990: isblk(loc) == 0');
	vrfy(isblk(a) == 0,		  '5991: isblk(a) == 0');
	vrfy(isblk(ofd) == 0,		  '5992: isblk(ofd) == 0');
	vrfy(isblk(cfd) == 0,		  '5993: isblk(cfd) == 0');
	vrfy(isblk(blk) == 1,		  '5994: isblk(blk) == 1');
	vrfy(isblk(nblk) == 2,		  '5995: isblk(nblk) == 2');
	vrfy(isblk(cfg) == 0,		  '5996: isblk(cfg) == 0');
	vrfy(isblk(serr) == 0,		  '5997: isblk(serr) == 0');
	vrfy(isblk(nerr) == 0,		  '5998: isblk(nerr) == 0');
	vrfy(isblk(odd) == 0,		  '5999: isblk(odd) == 0');
	vrfy(isblk(even) == 0,		  '6000: isblk(even) == 0');
	vrfy(isblk(hash) == 0,		  '6001: isblk(hash) == 0');
	vrfy(isblk(id) == 0,		  '6002: isblk(id) == 0');
	vrfy(isblk(list) == 0,		  '6003: isblk(list) == 0');
	vrfy(isblk(matrix) == 0,	  '6004: isblk(matrix) == 0');
	vrfy(isblk(nul) == 0,		  '6005: isblk(nul) == 0');
	vrfy(isblk(object) == 0,	  '6006: isblk(object) == 0');
	vrfy(isblk(rand) == 0,		  '6007: isblk(rand) == 0');
	vrfy(isblk(random) == 0,	  '6008: isblk(random) == 0');
	vrfy(isblk(real) == 0,		  '6009: isblk(real) == 0');
	vrfy(isblk(prime) == 0,		  '6010: isblk(prime) == 0');
	vrfy(isblk(square) == 0,	  '6011: isblk(square) == 0');
	vrfy(isblk(string) == 0,	  '6012: isblk(string) == 0');
	vrfy(isblk(com) == 0,		  '6013: isblk(com) == 0');
	print				  '6014: test unused';
	print				  '6015: test unused';
	print				  '6015: test unused';
	print				  '6016: test unused';
	print				  '6017: test unused';
	print				  '6018: test unused';
	print				  '6019: test unused';

	/*
	 * test isconfig
	 */
	vrfy(isconfig(loc) == 0,	  '6020: isconfig(loc) == 0');
	vrfy(isconfig(a) == 0,		  '6021: isconfig(a) == 0');
	vrfy(isconfig(ofd) == 0,	  '6022: isconfig(ofd) == 0');
	vrfy(isconfig(cfd) == 0,	  '6023: isconfig(cfd) == 0');
	vrfy(isconfig(blk) == 0,	  '6024: isconfig(blk) == 0');
	vrfy(isconfig(nblk) == 0,	  '6025: isconfig(nblk) == 0');
	vrfy(isconfig(cfg) == 1,	  '6026: isconfig(cfg) == 1');
	vrfy(isconfig(serr) == 0,	  '6027: isconfig(serr) == 0');
	vrfy(isconfig(nerr) == 0,	  '6028: isconfig(nerr) == 0');
	vrfy(isconfig(odd) == 0,	  '6029: isconfig(odd) == 0');
	vrfy(isconfig(even) == 0,	  '6030: isconfig(even) == 0');
	vrfy(isconfig(hash) == 0,	  '6031: isconfig(hash) == 0');
	vrfy(isconfig(id) == 0,		  '6032: isconfig(id) == 0');
	vrfy(isconfig(list) == 0,	  '6033: isconfig(list) == 0');
	vrfy(isconfig(matrix) == 0,	  '6034: isconfig(matrix) == 0');
	vrfy(isconfig(nul) == 0,	  '6035: isconfig(nul) == 0');
	vrfy(isconfig(object) == 0,	  '6036: isconfig(object) == 0');
	vrfy(isconfig(rand) == 0,	  '6037: isconfig(rand) == 0');
	vrfy(isconfig(random) == 0,	  '6038: isconfig(random) == 0');
	vrfy(isconfig(real) == 0,	  '6039: isconfig(real) == 0');
	vrfy(isconfig(prime) == 0,	  '6040: isconfig(prime) == 0');
	vrfy(isconfig(square) == 0,	  '6041: isconfig(square) == 0');
	vrfy(isconfig(string) == 0,	  '6042: isconfig(string) == 0');
	vrfy(isconfig(com) == 0,	  '6043: isconfig(com) == 0');
	print				  '6044: test unused';
	print				  '6045: test unused';
	print				  '6045: test unused';
	print				  '6046: test unused';
	print				  '6047: test unused';
	print				  '6048: test unused';
	print				  '6049: test unused';

	/*
	 * test isdefined
	 */
	vrfy(isdefined("loc") == 0,	  '6050: isdefined("loc") == 0');
	vrfy(isdefined("a") == 0,	  '6051: isdefined("a") == 0');
	vrfy(isdefined("ofd") == 0,	  '6052: isdefined("ofd") == 0');
	vrfy(isdefined("cfd") == 0,	  '6053: isdefined("cfd") == 0');
	vrfy(isdefined("blk") == 1,	  '6054: isdefined("blk") == 1');
	vrfy(isdefined("nblk") == 0,	  '6055: isdefined("nblk") == 0');
	vrfy(isdefined("cfg") == 0,	  '6056: isdefined("cfg") == 0');
	vrfy(isdefined("serr") == 0,	  '6057: isdefined("serr") == 0');
	vrfy(isdefined("nerr") == 0,	  '6058: isdefined("nerr") == 0');
	vrfy(isdefined("odd") == 0,	  '6059: isdefined("odd") == 0');
	vrfy(isdefined("even") == 0,	  '6060: isdefined("even") == 0');
	vrfy(isdefined("hash") == 1,	  '6061: isdefined("hash") == 1');
	vrfy(isdefined("id") == 0,	  '6062: isdefined("id") == 0');
	vrfy(isdefined("list") == 1,	  '6063: isdefined("list") == 1');
	vrfy(isdefined("matrix") == 0,	  '6064: isdefined("matrix") == 0');
	vrfy(isdefined("nul") == 0,	  '6065: isdefined("nul") == 0');
	vrfy(isdefined("object") == 0,	  '6066: isdefined("object") == 0');
	vrfy(isdefined("rand") == 1,	  '6067: isdefined("rand") == 1');
	vrfy(isdefined("random") == 1,	  '6068: isdefined("random") == 1');
	vrfy(isdefined("real") == 0,	  '6069: isdefined("real") == 0');
	vrfy(isdefined("prime") == 0,	  '6070: isdefined("prime") == 0');
	vrfy(isdefined("square") == 0,	  '6071: isdefined("square") == 0');
	vrfy(isdefined("string") == 0,	  '6072: isdefined("string") == 0');
	vrfy(isdefined("abs") == 1,	  '6073: isdefined("abs") == 1');
	vrfy(isdefined("notafunc") == 0,  '6074: isdefined("notafunc") == 0');
	vrfy(isdefined("com") == 0,	  '6075: isdefined("com") == 0');
	print				  '6076: test unused';
	print				  '6077: test unused';
	print				  '6078: test unused';
	print				  '6079: test unused';

	/*
	 * test iserror
	 */
	vrfy(iserror(loc) == 0,		  '6080: iserror(loc) == 0');
	vrfy(iserror(a) == 0,		  '6081: iserror(a) == 0');
	vrfy(iserror(ofd) == 0,		  '6082: iserror(ofd) == 0');
	vrfy(iserror(cfd) == 0,		  '6083: iserror(cfd) == 0');
	vrfy(iserror(blk) == 0,		  '6084: iserror(blk) == 0');
	vrfy(iserror(nblk) == 0,	  '6085: iserror(nblk) == 0');
	vrfy(iserror(cfg) == 0,		  '6086: iserror(cfg) == 0');
	vrfy(iserror(serr) == 1,	  '6087: iserror(serr) == 1');
	vrfy(iserror(nerr) > 0,		  '6088: iserror(nerr) > 0');
	vrfy(iserror(odd) == 0,		  '6089: iserror(odd) == 0');
	vrfy(iserror(even) == 0,	  '6090: iserror(even) == 0');
	vrfy(iserror(hash) == 0,	  '6091: iserror(hash) == 0');
	vrfy(iserror(id) == 0,		  '6092: iserror(id) == 0');
	vrfy(iserror(list) == 0,	  '6093: iserror(list) == 0');
	vrfy(iserror(matrix) == 0,	  '6094: iserror(matrix) == 0');
	vrfy(iserror(nul) == 0,		  '6095: iserror(nul) == 0');
	vrfy(iserror(object) == 0,	  '6096: iserror(object) == 0');
	vrfy(iserror(rand) == 0,	  '6097: iserror(rand) == 0');
	vrfy(iserror(random) == 0,	  '6098: iserror(random) == 0');
	vrfy(iserror(real) == 0,	  '6099: iserror(real) == 0');
	vrfy(iserror(prime) == 0,	  '6100: iserror(prime) == 0');
	vrfy(iserror(square) == 0,	  '6101: iserror(square) == 0');
	vrfy(iserror(string) == 0,	  '6102: iserror(string) == 0');
	vrfy(iserror(com) == 0,		  '6103: iserror(com) == 0');
	print				  '6104: test unused';
	print				  '6105: test unused';
	print				  '6105: test unused';
	print				  '6106: test unused';
	print				  '6107: test unused';
	print				  '6108: test unused';
	print				  '6109: test unused';

	/*
	 * test iseven
	 */
	vrfy(iseven(loc) == 1,		  '6110: iseven(loc) == 1');
	vrfy(iseven(a) == 0,		  '6111: iseven(a) == 0');
	vrfy(iseven(ofd) == 0,		  '6112: iseven(ofd) == 0');
	vrfy(iseven(cfd) == 0,		  '6113: iseven(cfd) == 0');
	vrfy(iseven(blk) == 0,		  '6114: iseven(blk) == 0');
	vrfy(iseven(nblk) == 0,		  '6115: iseven(nblk) == 0');
	vrfy(iseven(cfg) == 0,		  '6116: iseven(cfg) == 0');
	vrfy(iseven(serr) == 0,		  '6117: iseven(serr) == 0');
	vrfy(iseven(nerr) == 0,		  '6118: iseven(nerr) == 0');
	vrfy(iseven(odd) == 0,		  '6119: iseven(odd) == 0');
	vrfy(iseven(even) == 1,		  '6120: iseven(even) == 1');
	vrfy(iseven(hash) == 0,		  '6121: iseven(hash) == 0');
	vrfy(iseven(id) == 0,		  '6122: iseven(id) == 0');
	vrfy(iseven(list) == 0,		  '6123: iseven(list) == 0');
	vrfy(iseven(matrix) == 0,	  '6124: iseven(matrix) == 0');
	vrfy(iseven(nul) == 0,		  '6125: iseven(nul) == 0');
	vrfy(iseven(object) == 0,	  '6126: iseven(object) == 0');
	vrfy(iseven(rand) == 0,		  '6127: iseven(rand) == 0');
	vrfy(iseven(random) == 0,	  '6128: iseven(random) == 0');
	vrfy(iseven(real) == 0,		  '6129: iseven(real) == 0');
	vrfy(iseven(prime) == 0,	  '6130: iseven(prime) == 0');
	vrfy(iseven(square) == 0,	  '6131: iseven(square) == 0');
	vrfy(iseven(string) == 0,	  '6132: iseven(string) == 0');
	vrfy(iseven(com) == 0,		  '6133: iseven(com) == 0');
	print				  '6134: test unused';
	print				  '6135: test unused';
	print				  '6135: test unused';
	print				  '6136: test unused';
	print				  '6137: test unused';
	print				  '6138: test unused';
	print				  '6139: test unused';

	/*
	 * test isfile
	 */
	vrfy(isfile(loc) == 0,		  '6140: isfile(loc) == 0');
	vrfy(isfile(a) == 0,		  '6141: isfile(a) == 0');
	vrfy(isfile(ofd) == 1,		  '6142: isfile(ofd) == 1');
	vrfy(isfile(cfd) == 1,		  '6143: isfile(cfd) == 1');
	vrfy(isfile(blk) == 0,		  '6144: isfile(blk) == 0');
	vrfy(isfile(nblk) == 0,		  '6145: isfile(nblk) == 0');
	vrfy(isfile(cfg) == 0,		  '6146: isfile(cfg) == 0');
	vrfy(isfile(serr) == 0,		  '6147: isfile(serr) == 0');
	vrfy(isfile(nerr) == 0,		  '6148: isfile(nerr) == 0');
	vrfy(isfile(odd) == 0,		  '6149: isfile(odd) == 0');
	vrfy(isfile(even) == 0,		  '6150: isfile(even) == 0');
	vrfy(isfile(hash) == 0,		  '6151: isfile(hash) == 0');
	vrfy(isfile(id) == 0,		  '6152: isfile(id) == 0');
	vrfy(isfile(list) == 0,		  '6153: isfile(list) == 0');
	vrfy(isfile(matrix) == 0,	  '6154: isfile(matrix) == 0');
	vrfy(isfile(nul) == 0,		  '6155: isfile(nul) == 0');
	vrfy(isfile(object) == 0,	  '6156: isfile(object) == 0');
	vrfy(isfile(rand) == 0,		  '6157: isfile(rand) == 0');
	vrfy(isfile(random) == 0,	  '6158: isfile(random) == 0');
	vrfy(isfile(real) == 0,		  '6159: isfile(real) == 0');
	vrfy(isfile(prime) == 0,	  '6160: isfile(prime) == 0');
	vrfy(isfile(square) == 0,	  '6161: isfile(square) == 0');
	vrfy(isfile(string) == 0,	  '6162: isfile(string) == 0');
	vrfy(isfile(com) == 0,		  '6163: isfile(com) == 0');
	vrfy(isfile(files(0)) == 1,	  '6164: isfile(files(0)) == 1');
	vrfy(isfile(files(1)) == 1,	  '6165: isfile(files(1)) == 1');
	vrfy(isfile(files(2)) == 1,	  '6166: isfile(files(2)) == 1');
	vrfy(isfile(files(3)) == 1,	  '6167: isfile(files(3)) == 1');
	print				  '6168: test unused';
	print				  '6169: test unused';

	/*
	 * test ishash
	 */
	vrfy(ishash(loc) == 0,		  '6170: ishash(loc) == 0');
	vrfy(ishash(a) == 0,		  '6171: ishash(a) == 0');
	vrfy(ishash(ofd) == 0,		  '6172: ishash(ofd) == 0');
	vrfy(ishash(cfd) == 0,		  '6173: ishash(cfd) == 0');
	vrfy(ishash(blk) == 0,		  '6174: ishash(blk) == 0');
	vrfy(ishash(nblk) == 0,		  '6175: ishash(nblk) == 0');
	vrfy(ishash(cfg) == 0,		  '6176: ishash(cfg) == 0');
	vrfy(ishash(serr) == 0,		  '6177: ishash(serr) == 0');
	vrfy(ishash(nerr) == 0,		  '6178: ishash(nerr) == 0');
	vrfy(ishash(odd) == 0,		  '6179: ishash(odd) == 0');
	vrfy(ishash(even) == 0,		  '6180: ishash(even) == 0');
	vrfy(ishash(hash) == 2,		  '6181: ishash(hash) == 2');
	vrfy(ishash(id) == 0,		  '6182: ishash(id) == 0');
	vrfy(ishash(list) == 0,		  '6183: ishash(list) == 0');
	vrfy(ishash(matrix) == 0,	  '6184: ishash(matrix) == 0');
	vrfy(ishash(nul) == 0,		  '6185: ishash(nul) == 0');
	vrfy(ishash(object) == 0,	  '6186: ishash(object) == 0');
	vrfy(ishash(rand) == 0,		  '6187: ishash(rand) == 0');
	vrfy(ishash(random) == 0,	  '6188: ishash(random) == 0');
	vrfy(ishash(real) == 0,		  '6189: ishash(real) == 0');
	vrfy(ishash(prime) == 0,	  '6190: ishash(prime) == 0');
	vrfy(ishash(square) == 0,	  '6191: ishash(square) == 0');
	vrfy(ishash(string) == 0,	  '6192: ishash(string) == 0');
	vrfy(ishash(com) == 0,		  '6193: ishash(com) == 0');
	print				  '6194: test unused';
	print				  '6195: test unused';
	print				  '6196: test unused';
	print				  '6197: test unused';
	print				  '6198: test unused';
	print				  '6199: test unused';

	/*
	 * test isident
	 */
	vrfy(isident(loc) == 0,		  '6200: isident(loc) == 0');
	vrfy(isident(a) == 0,		  '6201: isident(a) == 0');
	vrfy(isident(ofd) == 0,		  '6202: isident(ofd) == 0');
	vrfy(isident(cfd) == 0,		  '6203: isident(cfd) == 0');
	vrfy(isident(blk) == 0,		  '6204: isident(blk) == 0');
	vrfy(isident(nblk) == 0,	  '6205: isident(nblk) == 0');
	vrfy(isident(cfg) == 0,		  '6206: isident(cfg) == 0');
	vrfy(isident(serr) == 0,	  '6207: isident(serr) == 0');
	vrfy(isident(nerr) == 0,	  '6208: isident(nerr) == 0');
	vrfy(isident(odd) == 0,		  '6209: isident(odd) == 0');
	vrfy(isident(even) == 0,	  '6210: isident(even) == 0');
	vrfy(isident(hash) == 0,	  '6211: isident(hash) == 0');
	vrfy(isident(id) == 1,		  '6212: isident(id) == 1');
	vrfy(isident(list) == 0,	  '6213: isident(list) == 0');
	vrfy(isident(matrix) == 0,	  '6214: isident(matrix) == 0');
	vrfy(isident(nul) == 0,		  '6215: isident(nul) == 0');
	vrfy(isident(object) == 0,	  '6216: isident(object) == 0');
	vrfy(isident(rand) == 0,	  '6217: isident(rand) == 0');
	vrfy(isident(random) == 0,	  '6218: isident(random) == 0');
	vrfy(isident(real) == 0,	  '6219: isident(real) == 0');
	vrfy(isident(prime) == 0,	  '6220: isident(prime) == 0');
	vrfy(isident(square) == 0,	  '6221: isident(square) == 0');
	vrfy(isident(string) == 0,	  '6222: isident(string) == 0');
	vrfy(isident(com) == 0,		  '6223: isident(com) == 0');
	print				  '6224: test unused';
	print				  '6225: test unused';
	print				  '6226: test unused';
	print				  '6227: test unused';
	print				  '6228: test unused';
	print				  '6229: test unused';

	/*
	 * test isint
	 */
	vrfy(isint(loc) == 1,		  '6230: isint(loc) == 1');
	vrfy(isint(a) == 0,		  '6231: isint(a) == 0');
	vrfy(isint(ofd) == 0,		  '6232: isint(ofd) == 0');
	vrfy(isint(cfd) == 0,		  '6233: isint(cfd) == 0');
	vrfy(isint(blk) == 0,		  '6234: isint(blk) == 0');
	vrfy(isint(nblk) == 0,		  '6235: isint(nblk) == 0');
	vrfy(isint(cfg) == 0,		  '6236: isint(cfg) == 0');
	vrfy(isint(serr) == 0,		  '6237: isint(serr) == 0');
	vrfy(isint(nerr) == 0,		  '6238: isint(nerr) == 0');
	vrfy(isint(odd) == 1,		  '6239: isint(odd) == 1');
	vrfy(isint(even) == 1,		  '6240: isint(even) == 1');
	vrfy(isint(hash) == 0,		  '6241: isint(hash) == 0');
	vrfy(isint(id) == 0,		  '6242: isint(id) == 0');
	vrfy(isint(list) == 0,		  '6243: isint(list) == 0');
	vrfy(isint(matrix) == 0,	  '6244: isint(matrix) == 0');
	vrfy(isint(nul) == 0,		  '6245: isint(nul) == 0');
	vrfy(isint(object) == 0,	  '6246: isint(object) == 0');
	vrfy(isint(rand) == 0,		  '6247: isint(rand) == 0');
	vrfy(isint(random) == 0,	  '6248: isint(random) == 0');
	vrfy(isint(real) == 0,		  '6249: isint(real) == 0');
	vrfy(isint(prime) == 1,		  '6250: isint(prime) == 1');
	vrfy(isint(square) == 1,	  '6251: isint(square) == 1');
	vrfy(isint(string) == 0,	  '6252: isint(string) == 0');
	vrfy(isint(com) == 0,		  '6253: isint(com) == 0');
	print				  '6254: test unused';
	print				  '6255: test unused';
	print				  '6255: test unused';
	print				  '6256: test unused';
	print				  '6257: test unused';
	print				  '6258: test unused';
	print				  '6259: test unused';

	/*
	 * test islist
	 */
	vrfy(islist(loc) == 0,		  '6260: islist(loc) == 0');
	vrfy(islist(a) == 0,		  '6261: islist(a) == 0');
	vrfy(islist(ofd) == 0,		  '6262: islist(ofd) == 0');
	vrfy(islist(cfd) == 0,		  '6263: islist(cfd) == 0');
	vrfy(islist(blk) == 0,		  '6264: islist(blk) == 0');
	vrfy(islist(nblk) == 0,		  '6265: islist(nblk) == 0');
	vrfy(islist(cfg) == 0,		  '6266: islist(cfg) == 0');
	vrfy(islist(serr) == 0,		  '6267: islist(serr) == 0');
	vrfy(islist(nerr) == 0,		  '6268: islist(nerr) == 0');
	vrfy(islist(odd) == 0,		  '6269: islist(odd) == 0');
	vrfy(islist(even) == 0,		  '6270: islist(even) == 0');
	vrfy(islist(hash) == 0,		  '6271: islist(hash) == 0');
	vrfy(islist(id) == 0,		  '6272: islist(id) == 0');
	vrfy(islist(list) == 1,		  '6273: islist(list) == 1');
	vrfy(islist(matrix) == 0,	  '6274: islist(matrix) == 0');
	vrfy(islist(nul) == 0,		  '6275: islist(nul) == 0');
	vrfy(islist(object) == 0,	  '6276: islist(object) == 0');
	vrfy(islist(rand) == 0,		  '6277: islist(rand) == 0');
	vrfy(islist(random) == 0,	  '6278: islist(random) == 0');
	vrfy(islist(real) == 0,		  '6279: islist(real) == 0');
	vrfy(islist(prime) == 0,	  '6280: islist(prime) == 0');
	vrfy(islist(square) == 0,	  '6281: islist(square) == 0');
	vrfy(islist(string) == 0,	  '6282: islist(string) == 0');
	vrfy(islist(com) == 0,		  '6283: islist(com) == 0');
	print				  '6284: test unused';
	print				  '6255: test unused';
	print				  '6285: test unused';
	print				  '6286: test unused';
	print				  '6287: test unused';
	print				  '6288: test unused';
	print				  '6289: test unused';

	/*
	 * test ismat
	 */
	vrfy(ismat(loc) == 0,		  '6290: ismat(loc) == 0');
	vrfy(ismat(a) == 0,		  '6291: ismat(a) == 0');
	vrfy(ismat(ofd) == 0,		  '6292: ismat(ofd) == 0');
	vrfy(ismat(cfd) == 0,		  '6293: ismat(cfd) == 0');
	vrfy(ismat(blk) == 0,		  '6294: ismat(blk) == 0');
	vrfy(ismat(nblk) == 0,		  '6295: ismat(nblk) == 0');
	vrfy(ismat(cfg) == 0,		  '6296: ismat(cfg) == 0');
	vrfy(ismat(serr) == 0,		  '6297: ismat(serr) == 0');
	vrfy(ismat(nerr) == 0,		  '6298: ismat(nerr) == 0');
	vrfy(ismat(odd) == 0,		  '6299: ismat(odd) == 0');
	vrfy(ismat(even) == 0,		  '6300: ismat(even) == 0');
	vrfy(ismat(hash) == 0,		  '6301: ismat(hash) == 0');
	vrfy(ismat(id) == 1,		  '6302: ismat(id) == 1');
	vrfy(ismat(list) == 0,		  '6303: ismat(list) == 0');
	vrfy(ismat(matrix) == 1,	  '6304: ismat(matrix) == 1');
	vrfy(ismat(nul) == 0,		  '6305: ismat(nul) == 0');
	vrfy(ismat(object) == 0,	  '6306: ismat(object) == 0');
	vrfy(ismat(rand) == 0,		  '6307: ismat(rand) == 0');
	vrfy(ismat(random) == 0,	  '6308: ismat(random) == 0');
	vrfy(ismat(real) == 0,		  '6309: ismat(real) == 0');
	vrfy(ismat(prime) == 0,		  '6310: ismat(prime) == 0');
	vrfy(ismat(square) == 0,	  '6311: ismat(square) == 0');
	vrfy(ismat(string) == 0,	  '6312: ismat(string) == 0');
	vrfy(ismat(com) == 0,		  '6313: ismat(com) == 0');
	print				  '6314: test unused';
	print				  '6215: test unused';
	print				  '6315: test unused';
	print				  '6316: test unused';
	print				  '6317: test unused';
	print				  '6318: test unused';
	print				  '6319: test unused';

	/*
	 * test ismult
	 */
	vrfy(ismult(odd,even) == 0,	  '6320: ismult(odd,even) == 0');
	vrfy(ismult(even,odd) == 1,	  '6321: ismult(even,odd) == 1');
	vrfy(ismult(odd,odd) == 1,	  '6322: ismult(odd,odd) == 1');
	vrfy(ismult(even,prime) == 0,	  '6323: ismult(even,prime) == 0');
	vrfy(ismult(square,prime) == 1,	  '6324: ismult(square,prime) == 1');
	vrfy(ismult(real,prime) == 0,	  '6325: ismult(real,prime) == 0');
	vrfy(ismult(real,real*34) == 0,	  '6326: ismult(real,real*34) == 0');
	vrfy(ismult(real*34,real) == 1,	  '6327: ismult(real*34,real) == 1');
	print				  '6328: test unused';
	print				  '6329: test unused';

	/*
	 * test isnull
	 */
	vrfy(isnull(loc) == 0,		  '6330: isnull(loc) == 0');
	vrfy(isnull(a) == 0,		  '6331: isnull(a) == 0');
	vrfy(isnull(ofd) == 0,		  '6332: isnull(ofd) == 0');
	vrfy(isnull(cfd) == 0,		  '6333: isnull(cfd) == 0');
	vrfy(isnull(blk) == 0,		  '6334: isnull(blk) == 0');
	vrfy(isnull(nblk) == 0,		  '6335: isnull(nblk) == 0');
	vrfy(isnull(cfg) == 0,		  '6336: isnull(cfg) == 0');
	vrfy(isnull(serr) == 0,		  '6337: isnull(serr) == 0');
	vrfy(isnull(nerr) == 0,		  '6338: isnull(nerr) == 0');
	vrfy(isnull(odd) == 0,		  '6339: isnull(odd) == 0');
	vrfy(isnull(even) == 0,		  '6340: isnull(even) == 0');
	vrfy(isnull(hash) == 0,		  '6341: isnull(hash) == 0');
	vrfy(isnull(id) == 0,		  '6342: isnull(id) == 0');
	vrfy(isnull(list) == 0,		  '6343: isnull(list) == 0');
	vrfy(isnull(matrix) == 0,	  '6344: isnull(matrix) == 0');
	vrfy(isnull(nul) == 1,		  '6345: isnull(nul) == 1');
	vrfy(isnull(object) == 0,	  '6346: isnull(object) == 0');
	vrfy(isnull(rand) == 0,		  '6347: isnull(rand) == 0');
	vrfy(isnull(random) == 0,	  '6348: isnull(random) == 0');
	vrfy(isnull(real) == 0,		  '6349: isnull(real) == 0');
	vrfy(isnull(prime) == 0,	  '6350: isnull(prime) == 0');
	vrfy(isnull(square) == 0,	  '6351: isnull(square) == 0');
	vrfy(isnull(string) == 0,	  '6352: isnull(string) == 0');
	vrfy(isnull(com) == 0,		  '6353: isnull(com) == 0');
	print				  '6354: test unused';
	print				  '6355: test unused';
	print				  '6355: test unused';
	print				  '6356: test unused';
	print				  '6357: test unused';
	print				  '6358: test unused';
	print				  '6359: test unused';

	/*
	 * test isnum
	 */
	vrfy(isnum(loc) == 1,		  '6360: isnum(loc) == 1');
	vrfy(isnum(a) == 0,		  '6361: isnum(a) == 0');
	vrfy(isnum(ofd) == 0,		  '6362: isnum(ofd) == 0');
	vrfy(isnum(cfd) == 0,		  '6363: isnum(cfd) == 0');
	vrfy(isnum(blk) == 0,		  '6364: isnum(blk) == 0');
	vrfy(isnum(nblk) == 0,		  '6365: isnum(nblk) == 0');
	vrfy(isnum(cfg) == 0,		  '6366: isnum(cfg) == 0');
	vrfy(isnum(serr) == 0,		  '6367: isnum(serr) == 0');
	vrfy(isnum(nerr) == 0,		  '6368: isnum(nerr) == 0');
	vrfy(isnum(odd) == 1,		  '6369: isnum(odd) == 1');
	vrfy(isnum(even) == 1,		  '6370: isnum(even) == 1');
	vrfy(isnum(hash) == 0,		  '6371: isnum(hash) == 0');
	vrfy(isnum(id) == 0,		  '6372: isnum(id) == 0');
	vrfy(isnum(list) == 0,		  '6373: isnum(list) == 0');
	vrfy(isnum(matrix) == 0,	  '6374: isnum(matrix) == 0');
	vrfy(isnum(nul) == 0,		  '6375: isnum(nul) == 0');
	vrfy(isnum(object) == 0,	  '6376: isnum(object) == 0');
	vrfy(isnum(rand) == 0,		  '6377: isnum(rand) == 0');
	vrfy(isnum(random) == 0,	  '6378: isnum(random) == 0');
	vrfy(isnum(real) == 1,		  '6379: isnum(real) == 1');
	vrfy(isnum(prime) == 1,		  '6380: isnum(prime) == 1');
	vrfy(isnum(square) == 1,	  '6381: isnum(square) == 1');
	vrfy(isnum(string) == 0,	  '6382: isnum(string) == 0');
	vrfy(isnum(com) == 1,		  '6379: isnum(com) == 1');
	print				  '6384: test unused';
	print				  '6385: test unused';
	print				  '6385: test unused';
	print				  '6386: test unused';
	print				  '6387: test unused';
	print				  '6388: test unused';
	print				  '6389: test unused';

	/*
	 * test isobj
	 */
	vrfy(isobj(loc) == 0,		  '6390: isobj(loc) == 0');
	vrfy(isobj(a) == 0,		  '6391: isobj(a) == 0');
	vrfy(isobj(ofd) == 0,		  '6392: isobj(ofd) == 0');
	vrfy(isobj(cfd) == 0,		  '6393: isobj(cfd) == 0');
	vrfy(isobj(blk) == 0,		  '6394: isobj(blk) == 0');
	vrfy(isobj(nblk) == 0,		  '6395: isobj(nblk) == 0');
	vrfy(isobj(cfg) == 0,		  '6396: isobj(cfg) == 0');
	vrfy(isobj(serr) == 0,		  '6397: isobj(serr) == 0');
	vrfy(isobj(nerr) == 0,		  '6398: isobj(nerr) == 0');
	vrfy(isobj(odd) == 0,		  '6399: isobj(odd) == 0');
	vrfy(isobj(even) == 0,		  '6400: isobj(even) == 0');
	vrfy(isobj(hash) == 0,		  '6401: isobj(hash) == 0');
	vrfy(isobj(id) == 0,		  '6402: isobj(id) == 0');
	vrfy(isobj(list) == 0,		  '6403: isobj(list) == 0');
	vrfy(isobj(matrix) == 0,	  '6404: isobj(matrix) == 0');
	vrfy(isobj(nul) == 0,		  '6405: isobj(nul) == 0');
	vrfy(isobj(object) == 1,	  '6406: isobj(object) == 1');
	vrfy(isobj(rand) == 0,		  '6407: isobj(rand) == 0');
	vrfy(isobj(random) == 0,	  '6408: isobj(random) == 0');
	vrfy(isobj(real) == 0,		  '6409: isobj(real) == 0');
	vrfy(isobj(prime) == 0,		  '6410: isobj(prime) == 0');
	vrfy(isobj(square) == 0,	  '6411: isobj(square) == 0');
	vrfy(isobj(string) == 0,	  '6412: isobj(string) == 0');
	vrfy(isobj(com) == 0,		  '6413: isobj(com) == 0');
	print				  '6414: test unused';
	print				  '6415: test unused';
	print				  '6415: test unused';
	print				  '6416: test unused';
	print				  '6417: test unused';
	print				  '6418: test unused';
	print				  '6419: test unused';

	/*
	 * test isobjtype
	 */
	vrfy(isobjtype("loc") == 0,	  '6420: isobjtype("loc") == 0');
	vrfy(isobjtype("a") == 0,	  '6421: isobjtype("a") == 0');
	vrfy(isobjtype("ofd") == 0,	  '6422: isobjtype("ofd") == 0');
	vrfy(isobjtype("xy5800") == 1,	  '6423: isobjtype("xy5800") == 1');
	vrfy(isobjtype("xy5900") == 1,	  '6424: isobjtype("xy5900") == 1');
	print				  '6425: test unused';
	print				  '6426: test unused';
	print				  '6427: test unused';
	print				  '6428: test unused';
	print				  '6429: test unused';

	/*
	 * test isodd
	 */
	vrfy(isodd(loc) == 0,		  '6430: isodd(loc) == 0');
	vrfy(isodd(a) == 0,		  '6431: isodd(a) == 0');
	vrfy(isodd(ofd) == 0,		  '6432: isodd(ofd) == 0');
	vrfy(isodd(cfd) == 0,		  '6433: isodd(cfd) == 0');
	vrfy(isodd(blk) == 0,		  '6434: isodd(blk) == 0');
	vrfy(isodd(nblk) == 0,		  '6435: isodd(nblk) == 0');
	vrfy(isodd(cfg) == 0,		  '6436: isodd(cfg) == 0');
	vrfy(isodd(serr) == 0,		  '6437: isodd(serr) == 0');
	vrfy(isodd(nerr) == 0,		  '6438: isodd(nerr) == 0');
	vrfy(isodd(odd) == 1,		  '6439: isodd(odd) == 1');
	vrfy(isodd(even) == 0,		  '6440: isodd(even) == 0');
	vrfy(isodd(hash) == 0,		  '6441: isodd(hash) == 0');
	vrfy(isodd(id) == 0,		  '6442: isodd(id) == 0');
	vrfy(isodd(list) == 0,		  '6443: isodd(list) == 0');
	vrfy(isodd(matrix) == 0,	  '6444: isodd(matrix) == 0');
	vrfy(isodd(nul) == 0,		  '6445: isodd(nul) == 0');
	vrfy(isodd(object) == 0,	  '6446: isodd(object) == 0');
	vrfy(isodd(rand) == 0,		  '6447: isodd(rand) == 0');
	vrfy(isodd(random) == 0,	  '6448: isodd(random) == 0');
	vrfy(isodd(real) == 0,		  '6449: isodd(real) == 0');
	vrfy(isodd(prime) == 1,		  '6450: isodd(prime) == 1');
	vrfy(isodd(square) == 1,	  '6451: isodd(square) == 1');
	vrfy(isodd(string) == 0,	  '6452: isodd(string) == 0');
	vrfy(isodd(com) == 0,		  '6453: isodd(com) == 0');
	print				  '6454: test unused';
	print				  '6455: test unused';
	print				  '6455: test unused';
	print				  '6456: test unused';
	print				  '6457: test unused';
	print				  '6458: test unused';
	print				  '6459: test unused';

	/*
	 * test isprime
	 */
	vrfy(isprime(loc) == 0,		  '6460: isprime(loc) == 0');
	vrfy(isprime(odd) == 1,		  '6461: isprime(odd) == 1');
	vrfy(isprime(even) == 0,	  '6462: isprime(even) == 0');
	vrfy(isprime(prime) == 1,	  '6463: isprime(prime) == 1');
	vrfy(isprime(square) == 0,	  '6464: isprime(square) == 0');
	print				  '6465: test unused';
	print				  '6466: test unused';
	print				  '6468: test un