/*
 * Copyright (c) 1996 David I. Bell
 * Permission is granted to use, distribute, or modify this source,
 * provided that this copyright notice remains intact.
 *
 * Test the correct execution of the calculator by reading this library file.
 * Errors are reported with '****' messages, or worse.  :-)
 *
 * NOTE: Unlike most calc lib files, this one performs its work when
 *       it is read.  Normally one would just define functions and
 *	 values for later use.  In the case of the regression test,
 *	 we do not want to do this.
 */

print '000: Beginning regression tests';
print '001: Some of these tests may take a while ...';
print '002: Within each section, output should be numbered sequentially';


global err;
lib_debug = -1;				/* disable lib startup messages */
initcfg = config("all", "oldstd");	/* set config to startup default */
print '003: parsed global definitions';


/*
 * vrfy - vrfy that a test is true
 *
 * Counts and reports errors or prints test string if successful.
 */
define vrfy(test, str)
{
	if (test != 1) {
		print '**** Non-true result (' : test : '): ' : str;
		++err;
		return;
	}
	print str;
}
print '004: parsed vrfy()';


/*
 * err - alternate error notification and count
 */
define err(str)
{
	print '****' , str;
	++err;
}
print '005: parsed err(str)';


/*
 * getglobalvar - used to return a global value
 */
define getglobalvar()
{
	global	globalvar;

	return globalvar;
}
print '006: parsed getglobalvar()';


/*
 * Test boolean operations and IF tests.
 *
 * Some of these tests are done twice, once to print the message and
 * once to count any errors.  This means that some successful tests
 * will display a passing message twice.  Oh well, no biggie.
 */
define test_booleans()
{
	local	x;
	local	y;
	local	t1, t2, t3;

	print '200: Beginning test_booleans';

	if (0)
		print '**** if (0)';
	if (0)
		err = err + 1;

	if (1)
		print '201: if (1)';

	if (2)
		print '202: if (2)';

	if (1)
		print '203: if (1) else';
	else
		print '**** if (1) else';
	if (1)
		print '204: if (1) else';
	else
		err = err + 1;

	if (0)
		print '**** if (0) else';
	else
		print '205: if (0) else';
	if (0)
		err = err + 1;
	else
		print '206: if (0) else';

	if (1 == 1)
		print '207: if 1 == 1';
	else
		print '**** if 1 == 1';
	if (1 == 1)
		print '208: if 1 == 1';
	else
		err = err + 1;

	if (1 != 2)
		print '209: if 1 != 2';
	else
		print '**** if 1 != 2';
	if (1 != 2)
		print '210: if 1 != 2';
	else
		err = err + 1;

	vrfy(1,      '211: vrfy 1');
	vrfy(2 == 2, '212: vrfy 2 == 2');
	vrfy(2 != 3, '213: vrfy 2 != 3');
	vrfy(2 <  3, '214: vrfy 2 <  3');
	vrfy(2 <= 2, '215: vrfy 2 <= 2');
	vrfy(2 <= 3, '216: vrfy 2 <= 3');
	vrfy(3 >  2, '217: vrfy 3 >  2');
	vrfy(2 >= 2, '218: vrfy 2 >= 2');
	vrfy(3 >= 2, '219: vrfy 3 >= 2');
	vrfy(!0,     '220: vrfy !0');
	vrfy(!1 == 0,'221: vrfy !1 == 0');
	vrfy((1 ? 2 ? 3 : 4 : 5) == 3,    '222: (1 ? 2 ? 3 : 4 : 5) == 3');

	print '223: Ending test_booleans';
}
print '007: parsed test_booleans()';


/*
 * Test variables, simple assignments, AND and OR operators, short-circuit eval
 */
define test_variables()
{
	local	x1, x2, x3;
	global	g1, g2;
	local	t;
	global	globalvar;
	local x;

	print '300: Beginning test_variables';

	x1 = 5;
	x3 = 7 * 2;
	x2 = 9 + 1;
	globalvar = 22;
	g1 = 19 - 3;
	g2 = 79;
	vrfy(x1 == 5,			'301: x1 == 5');
	vrfy(x2 == 10,			'302: x2 == 10');
	vrfy(x3 == 14,			'303: x3 == 14');
	vrfy(g1 == 16,			'304: g1 == 16');
	vrfy(g2 == 79,			'305: g2 == 79');
	vrfy(globalvar == 22,		'306: globalvar == 22');
	vrfy(getglobalvar() == 22,	'307: getglobalvar() == 22');
	x1 = x2 + x3 + g1;
	vrfy(x1 == 40,			'308: x1 == 40');
	g1 = x3 + g2;
	vrfy(g1 == 93,			'309: g1 == 207');
	x1 = 5;
	vrfy(x1++ == 5,			'310: x1++ == 5');
	vrfy(x1 == 6,			'311: x1 == 6');
	vrfy(++x1 == 7,			'312: ++x1 == 7');
	x1 += 3;
	vrfy(x1 == 10,			'313: x1 == 10');
	x1 -= 6;
	vrfy(x1 == 4,			'314: x1 == 4');
	x1 *= 3;
	vrfy(x1 == 12,			'315: x1 == 12');
	x1 /= 4;
	vrfy(x1 == 3,			'316: x1 == 3');
	x1 = x2 = x3;
	vrfy(x2 == 14,			'317: x2 == 14');
	vrfy(x1 == 14,			'318: x1 == 14');

	if (2 && 3) {
		print '319: if (2 && 3)';
	} else {
		print '**** if (2 && 3)';
		++err;
	}

	if (2 && 0) {
		print '**** if (2 && 0)';
		++err;
	} else {
		print '320: if (2 && 0)';
	}

	if (0 && 2) {
		print '**** if (0 && 2)';
		++err;
	} else {
		print '321: if (0 && 2)';
	}

	if (0 && 0) {
		print '**** if (0 && 0)';
		++err;
	} else {
		print '322: if (0 && 0)';
	}

	if (2 || 0) {
		print '323: if (2 || 0)';
	} else {
		print '**** if (2 || 0)';
		++err;
	}

	if (0 || 2) {
		print '324: if (0 || 2)';
	} else {
		print '**** if (0 || 2)';
		++err;
	}

	if (0 || 0) {
		print '**** if (0 || 0)';
		++err;
	} else {
		print '325: if (0 || 0)';
	}

	x = 2 || 3; vrfy(x == 2,	'326: (2 || 3) == 2');
	x = 2 || 0; vrfy(x == 2,	'327: (2 || 0) == 2');
	x = 0 || 3; vrfy(x == 3,	'328: (0 || 3) == 3');
	x = 0 || 0; vrfy(x == 0,	'329: (0 || 0) == 0');
	x = 2 && 3; vrfy(x == 3,	'330: (2 && 3) == 3');
	x = 2 && 0; vrfy(x == 0,	'331: (2 && 0) == 0');
	x = 0 && 3; vrfy(x == 0,	'332: (0 && 3) == 0');
	x = 2 || err('2 || err()');
	print			 	"333: x = 2 || err('2 || err()'";
	x = 0 && err('0 && err()');
	print				"334: x = 0 && err('0 && err()'";

	print				'335: Ending test_variables';
}
print '008: parsed test_variables()';


/*
 * Test simple arithmetic operations and expressions.
 */
define test_arithmetic()
{
	print '400: Beginning test_arithmetic';

	vrfy(3+4==7,		'401: 3 + 4 == 7');
	vrfy(4-1==3,		'402: 4 - 1 == 3');
	vrfy(2*3==6,		'403: 2 * 3 == 6');
	vrfy(8/4==2,		'404: 8 / 4 == 2');
	vrfy(2^3==8,		'405: 2 ^ 3 == 8');
	vrfy(9-4-2==3,		'406: 9-4-2 == 3');
	vrfy(9-4+2==7,		'407: 9-4+2 == 6');
	vrfy(-5+2==-3,		'408: -5+2 == -3');
	vrfy(2*3+1==7,		'409: 2*3+1 == 7');
	vrfy(1+2*3==7,		'410: 1+2*3 == 7');
	vrfy((1+2)*3==9,	'411: (1+2)*3 == 9');
	vrfy(2*(3+1)==8,	'412: 2*(3+1) == 8');
	vrfy(9-(2+3)==4,	'413: 9-(2+3) == 4');
	vrfy(9+(2-3)==8,	'414: 9+(2-3) == 8');
	vrfy((2+3)*(4+5)==45,	'415: (2+3)*(4+5) == 45');
	vrfy(10/(2+3)==2,	'416: 10/(2+3) == 2');
	vrfy(12/3+4==8,		'417: 12/3+4 == 8');
	vrfy(6+12/3==10,	'418: 6+12/3 == 10');
	vrfy(2+3==1+4,		'419: 2+3 == 1+4');
	vrfy(-(2+3)==-5,	'420: -(2+3) == -5');
	vrfy(7&18==2,  		'421: 7&18 == 2');
	vrfy(3|17==19,  	'422: 3|17 == 19');
	vrfy(2&3|1==3,  	'423: 2&3|1 == 3');
	vrfy(2&(3|1)==2,	'424: 2&(3|1) == 2');
	vrfy(3<<4==48,  	'425: 3<<4 == 48');
	vrfy(5>>1==2,   	'426: 5>>1 == 2');
	vrfy(3<<-1==1,  	'427: 3<<-1 == 1');
	vrfy(5>>-2==20, 	'428: 5>>-2 == 20');
	vrfy(1<<2<<3==65536,	'429: 1<<2<<3 == 65536');
	vrfy((1<<2)<<3==32,	'430: (1<<2)<<3 == 32');
	vrfy(2^3^2==512,	'431: 2^3^2 == 512');
	vrfy((2^3)^2==64,	'432: (2^3)^2 == 64');
	vrfy(4//3==1, 		'433: 4//3==1');
	vrfy(4//-3==-1, 	'434: 4//-3==-1');
	vrfy(0.75//-0.51==-1,	'435: 0.75//-0.51==-1');
	vrfy(0.75//-0.50==-1,	'436: 0.75//-0.50==-1');
	vrfy(0.75//-0.49==-1,	'437: 0.75//-0.49==-1');
	vrfy((3/4)//(-1/4)==-3, '438: (3/4)//(-1/4)==-3');
	vrfy(7%3==1,   		'439: 7%3==1');
	vrfy(0-.5==-.5,		'440: 0-.5==-.5');
	vrfy(0^0 == 1,  	'441: 0^0 == 1');
	vrfy(0^1 == 0,  	'442: 0^1 == 0');
	vrfy(1^0 == 1,  	'443: 1^0 == 1');
	vrfy(1^1 == 1,  	'444: 1^1 == 1');
	vrfy(1/(.8+.8i)==.625-.625i,	'445: 1/(.8+.8i)==.625-.625i');
	vrfy((.6+.8i)*(3.6-4.8i)==6,	'446: (.6+.8i)*(3.6-4.8i)==6');

	print '447: Ending test_arithmetic';
}
print '009: parsed test_arithmetic()';


/*
 * test_config - test config control
 */
define test_config()
{
	local callcfg;		/* caller configuration value */
	local oldcfg;		/* caller configuration value */
	local newcfg;		/* caller configuration value */

	print '500: Beginning test_config';

	/* check the set and return of all config */
	callcfg = config("all");
	print 				'501: callcfg = config("all")';
	callcfg = config("all", "oldstd");
	print 				'502: callcfg = config("all","oldstd")';
	oldcfg = config("all", "newstd");
	print 				'503: oldcfg = config("all","newstd")';
	vrfy(callcfg == oldcfg,	'504: callcfg == oldcfg');
	newcfg = config("all");
	print 				'505: newcfg = config("all")';
	vrfy(config("all") == newcfg,	'506: config("all") == newcfg');
	vrfy(config("all", oldcfg) == newcfg,
					'507: config("all", oldcfg) == newcfg');

	/* vrfy the state of the default config */
	vrfy(config("all") == oldcfg,	'508: config("all") == oldcfg');
	vrfy(config("mode") == "real",
					'509: config("mode") == "real"');
	vrfy(config("display") == 20,
					'510: config("display") == 20');
	vrfy(config("epsilon") == 1e-20,
					'511: config("epsilon") == 1e-20');
	vrfy(config("trace") == 0,
					'512: config("trace") == 0');
	vrfy(config("maxprint") == 16,
					'513: config("maxprint") == 16');
	vrfy(config("mul2") == 20,
					'514: config("mul2") == 20');
	vrfy(config("sq2") == 20,
					'515: config("sq2") == 20');
	vrfy(config("pow2") == 40,
					'516: config("pow2") == 40');
	vrfy(config("redc2") == 50,
					'517: config("redc2") == 50');
	vrfy(config("tilde") == 1,
					'518: config("tilde") == 1');
	vrfy(config("tab") == 1,
					'519: config("tab") == 1');
	vrfy(config("quomod") == 0,
					'520: config("quomod") == 0');
	vrfy(config("quo") == 2,
					'521: config("quo") == 2');
	vrfy(config("mod") == 0,
					'522: config("mod") == 0');
	vrfy(config("sqrt") == 24,
					'523: config("sqrt") == 24');
	vrfy(config("appr") == 24,
					'524: config("appr") == 24');
	vrfy(config("cfappr") == 0,
					'525: config("cfappr") == 0');
	vrfy(config("cfsim") == 8,
					'526: config("cfsim") == 8');
	vrfy(config("outround") == 2,
					'527: config("outround") == 2');
	vrfy(config("round") == 24,
					'528: config("round") == 24');
	vrfy(config("leadzero") == 0,
					'529: config("leadzero") == 0');
	vrfy(config("fullzero") == 0,
					'530: config("fullzero") == 0');
	vrfy(config("maxerr") == 20,
					'531: config("maxerr") == 20');
	vrfy(config("prompt") == "> ",
					'532: config("prompt") == "> "');
	vrfy(config("more") == ">> ",
					'533: config("more") == ">> "');

	/* convert to "newstd" config by individual changes */
	vrfy(config("display", 10) == 20,
					'534: config("display") == 20');
	vrfy(config("epsilon",1e-10)==1e-20,
					'535: config("epsilon",1e-10)==1e-20');
	vrfy(config("quo", 0) == 2,	'536: config("quo", 0) == 2');
	vrfy(config("outround", 24) == 2,
					'537: config("outround", 24) == 2');
	vrfy(config("leadzero", "y") == 0,
					'538: config("leadzero", "y") == 0');
	vrfy(config("fullzero", 1) == 0,
					'539: config("fullzero", 1) == 0');
	vrfy(config("prompt", "; ") == "> ",
					'540: config("prompt", "; ") == "> "');
	vrfy(config("more", ";; ") == ">> ",
					'541: config("more", ";; ") == ">> "');
	vrfy(config("all") == newcfg,	'542: config("all") == newcfg');

	/* check on the new config("fullzero") effect */
	vrfy(config("all","oldstd") == newcfg,
					'543: config("all",callcfg) == newcfg');
	vrfy(config("display",2) == 20,
					'544: config("display",2) == 20');
	vrfy(config("fullzero",1) == 0,
					'545: config("fullzero",1) == 0');
	vrfy(strprintf("%d %d %d", 0, 1, 2) == ".00 1.00 2.00",
		'546: strprintf("%d %d %d", 0, 1, 2) == ".00 1.00 2.00"');
	vrfy(config("display",20) == 2,
					'547: config("display",20) == 2');
	vrfy(config("fullzero",0) == 1,
					'548: config("fullzero",0) == 1');
	vrfy(strprintf("%d %d %d", 0, 1, 2) == "0 1 2",
		'549: strprintf("%d %d %d", 0, 1, 2) == "0 1 2"');

	/* restore calling config */
	vrfy(config("all",callcfg) == oldcfg,
					'550: config("all",callcfg) == oldcfg');
	vrfy(config("all") == callcfg,  '551: config("all") == callcfg');
	vrfy(config("all") == oldcfg,	'552: config("all") == oldcfg');

	print '553: Ending test_config';
}
print '010: parsed test_config()';



/*
 * Do multiplication and division on three numbers in various ways
 * and vrfy the results agree.
 */
define muldivcheck(a, b, c, str)
{
	local	abc, acb, bac, bca, cab, cba;

	abc = (a * b) * c;
	acb = (a * c) * b;
	bac = (b * a) * c;
	bca = (b * c) * a;
	cab = (c * a) * b;
	cba = (c * b) * a;

	if (abc != acb) {print '**** abc != acb:', str; ++err;}
	if (acb != bac) {print '**** acb != bac:', str; ++err;}
	if (bac != bca) {print '**** bac != bca:', str; ++err;}
	if (bca != cab) {print '**** bca != cab:', str; ++err;}
	if (cab != cba) {print '**** cab != cba:', str; ++err;}
	if (abc/a != b*c) {print '**** abc/a != bc:', str; ++err;}
	if (abc/b != a*c) {print '**** abc/b != ac:', str; ++err;}
	if (abc/c != a*b) {print '**** abc/c != ab:', str; ++err;}
	print str;
}
print '011: parsed muldivcheck(a, b, c, str)';


/*
 * Use the identity for squaring the sum of two squares to check
 * multiplication and squaring.
 */
define squarecheck(a, b, str)
{
	local	a2, b2, tab, apb, apb2, t;

	a2 = a^2;
	b2 = b^2;
	tab = a * b * 2;
	apb = a + b;
	apb2 = apb^2;
	if (a2 != a*a) {print '**** a^2 != a*a:', str; ++err;}
	if (b2 != b*b) {print '**** b^2 != b*b:', str; ++err;}
	if (apb2 != apb*apb) {
		print '**** (a+b)^2 != (a+b)*(a+b):', str;
		++err;
	}
	if (a2+tab+b2 != apb2) {
		print '**** (a+b)^2 != a^2 + 2ab + b^2:', str;
		++err;
	}
	if (a2/a != a) {print '**** a^2/a != a:', str; ++err;}
	if (b2/b != b) {print '**** b^2/b != b:', str; ++err;}
	if (apb2/apb != apb) {print '**** (a+b)^2/(a+b) != a+b:', str; ++err;}
	if (a2*b2 != (a*b)^2) {print '**** a^2*b^2 != (ab)^2:', str; ++err;}
	print str;
}
print '012: parsed squarecheck(a, b, str)';


/*
 * Use the raising of numbers to large powers to check multiplication
 * and exponentiation.
 */
define powercheck(a, p1, p2, str)
{
	local	a1, a2, a3;

	a1 = (a^p1)^p2;
	a2 = (a^p2)^p1;
	a3 = a^(p1*p2);
	if (a1 != a2) {print '**** (a^p1)^p2 != (a^p2)^p1:', str; ++err;}
	if (a1 != a3) {print '**** (a^p1)^p2 != a^(p1*p2):', str; ++err;}
	print str;
}
print '013: parsed powercheck(a, p1, p2, str)';


/*
 * Test fraction reductions.
 * Arguments MUST be relatively prime.
 */
define fraccheck(a, b, c, str)
{
	local	ab, bc, ca, aoc, boc, aob;

	ab = a * b;
	bc = b * c;
	ca = c * a;
	aoc = ab / bc;
	if (num(aoc) != a) {print '**** num(aoc) != a:', str; ++err;}
	if (den(aoc) != c) {print '**** den(aoc) != c:', str; ++err;}
	boc = ab / ca;
	if (num(boc) != b) {print '**** num(boc) != b:', str; ++err;}
	if (den(boc) != c) {print '**** den(boc) != c:', str; ++err;}
	aob = ca / bc;
	if (num(aob) != a) {print '**** num(aob) != a:', str; ++err;}
	if (den(aob) != b) {print '**** den(aob) != b:', str; ++err;}
	if (aob*boc != aoc) {print '**** aob*boc != aoc;', str; ++err;}
	print str;
}
print '014: parsed fraccheck(a, b, c, str)';


/*
 * Test multiplication and squaring algorithms.
 */
define algcheck(a, b, str)
{
	local	ss, ms, t1, t2, t3, t4, t5, t6, t7;
	local	a1, a2, a3, a4, a5, a6, a7;
	local	oldmul2, oldsq2;

	oldmul2 = config("mul2", 2);
	oldsq2 = config("sq2", 2);
	a1 = a * b;
	a2 = a * a;
	a3 = b * b;
	a4 = a^2;
	a5 = b^2;
	a6 = a2^2;
	a7 = pmod(3,a-1,a);
	for (ms = 2; ms < 20; ms++) {
		for (ss = 2; ss < 20; ss++) {
			config("mul2", ms);
			config("sq2", ss);
			t1 = a * b;
			t2 = a * a;
			t3 = b * b;
			t4 = a^2;
			t5 = b^2;
			t6 = t2^2;
			if (((ms + ss) % 37) == 4)
				t7 = pmod(3,a-1,a);
			if (t1 != a1) {print '**** t1 != a1:', str; ++err;}
			if (t2 != a2) {print '**** t2 != a2:', str; ++err;}
			if (t3 != a3) {print '**** t3 != a3:', str; ++err;}
			if (t4 != a4) {print '**** t4 != a4:', str; ++err;}
			if (t5 != a5) {print '**** t5 != a5:', str; ++err;}
			if (t6 != a6) {print '**** t6 != a6:', str; ++err;}
			if (t7 != a7) {print '**** t7 != a7:', str; ++err;}
		}
	}
	config("mul2", oldmul2);
	config("sq2", oldsq2);
	print str;
}
print '015: parsed algcheck(a, b, str)';


/*
 * Test big numbers using some identities.
 */
define test_bignums()
{
	local	a, b, c, d;

	print '600: Beginning test_bignums';

	a = 64357824568234938591;
	b = 12764632632458756817;
	c = 43578234973856347982;
	muldivcheck(a, b, c, '601: muldivcheck 1');
	a = 3^100;
	b = 5^97;
	c = 7^88;
	muldivcheck(a, b, c, '602: muldivcheck 2');
	a = 2^160 - 1;
	b = 2^161 - 1;
	c = 2^162 - 1;
	muldivcheck(a, b, c, '603: muldivcheck 3');
	a = 3^35 / 5^35;
	b = 7^35 / 11^35;
	c = 13^35 / 17^35;
	muldivcheck(a, b, c, '604: muldivcheck 4');
	a = (10^97-1) / 9;
	b = (10^53-1) / 9;
	c = (10^37-1) / 9;
	muldivcheck(a, b, c, '605: muldivcheck 5');
	a = 17^50;
	b = 19^47;
	squarecheck(a, b, '606: squarecheck 1');
	a = 2^111-1;
	b = 2^17;
	squarecheck(a, b, '607: squarecheck 2');
	a = 23^43 / 29^43;
	b = 31^42 / 37^29;
	squarecheck(a, b, '608: squarecheck 3');
	a = 4657892345743659834657238947854639;
	b = 43784356784365893467659347867689;
	squarecheck(a, b, '609: squarecheck 4');
	a = (10^80-1) / 9;
	b = (10^50-1) / 9;
	squarecheck(a, b, '610: squarecheck 5');
	a = 101^99;
	b = 2 * a;
	squarecheck(a, b, '611: squarecheck 6');
	a = (10^19-1) / 9;
	vrfy(ptest(a, 20), '612: primetest R19');
	a = (10^23-1) / 9;
	vrfy(ptest(a, 20), '613: primetest R23');
	a = 2^127 - 1;
	vrfy(ptest(a, 1), '614: primetest M127');
	a = 2^521 - 1;
	vrfy(ptest(a, 1), '615: primetest M521');
	powercheck(17, 127, 30, '616: powercheck 1');
	powercheck(111, 899, 6, '617: powercheck 2');
	powercheck(3, 87, 89, '618: powercheck 3');
	fraccheck(3^200, 5^173, 7^138, '619: fraccheck 1');
	fraccheck(11^100, 12^98, 13^121, '620: fraccheck 2');
	fraccheck(101^270, 103^111, 105^200, '621: fraccheck 3');
	a = 0xffff0000ffffffff00000000ffff0000000000000000ffff;
	b = 0x555544440000000000000000000000000000000011112222333344440000;
	c = 0x999911113333000011111111000022220000000000000000333300000000ffff;
	d = 0x3333ffffffff0000000000000000ffffffffffffffff000000000000;
	algcheck(a, a, '622: algcheck 1');
	algcheck(a, b, '623: algcheck 2');
	algcheck(a, c, '624: algcheck 3');
	algcheck(a, d, '625: algcheck 4');
	algcheck(b, b, '626: algcheck 5');
	algcheck(b, c, '627: algcheck 6');
	algcheck(b, d, '628: algcheck 7');
	algcheck(c, c, '629: algcheck 8');
	algcheck(c, d, '630: algcheck 9');
	algcheck(d, d, '631: algcheck 10');

	print '632: Ending test_bignums';
}
print '016: parsed test_bignums()';


/*
 * Test many of the built-in functions.
 */
define test_functions()
{
	local a, b;
	local pi;

	print '700: Beginning test_functions';

	vrfy(abs(3) == 3,    		'701: abs(3) == 3');
	vrfy(abs(-4) == 4,  		'702: abs(-4) == 4');
	vrfy(avg(7) == 7,  		'703: avg(7) == 7');
	vrfy(avg(3,5) == 4,		'704: avg(3,5) == 4');
	vrfy(cmp(2,3) == -1,		'705: cmp(2,3) == -1');
	vrfy(cmp(6,6) == 0,		'706: cmp(6,6) == 0');
	vrfy(cmp(7,4) == 1,		'707: cmp(7,4) == 1');
	vrfy(comb(9,9) == 1,		'708: comb(9,9) == 1');
	vrfy(comb(5,2) == 10,		'709: comb(5,2) == 10');
	vrfy(conj(4) == 4,   		'710: conj(4) == 4');
	vrfy(conj(2-3i) == 2+3i,	'711: conj(2-3i) == 2+3i');
	vrfy(den(17) == 1,   		'712: den(17) == 1');
	vrfy(den(3/7) == 7, 		'713: den(3/7) == 7');
	vrfy(den(-2/3) == 3,		'714: den(-2/3) == 3');
	vrfy(digits(0) == 1,		'715: digits(0) == 1');
	vrfy(digits(9) == 1,		'716: digits(9) == 1');
	vrfy(digits(10) == 2,		'717: digits(10) == 2');
	vrfy(digits(-691) == 3,		'718: digits(-691) == 3');
	vrfy(eval('2+3') == 5,		"719: eval('2+3') == 5");
	vrfy(fcnt(11,3) == 0,		'720: fcnt(11,3) == 0');
	vrfy(fcnt(18,3) == 2,		'721: fcnt(18,3) == 2');
	vrfy(fib(0) == 0,    		'722: fib(0) == 0');
	vrfy(fib(1) == 1,    		'723: fib(1) == 1');
	vrfy(fib(9) == 34,   		'724: fib(9) == 34');
	vrfy(frem(12,5) == 12,		'725: frem(12,5) == 12');
	vrfy(frem(45,3) == 5,		'726: frem(45,3) == 5');
	vrfy(fact(0) == 1,		'727: fact(0) == 1');
	vrfy(fact(1) == 1, 		'728: fact(1) == 1');
	vrfy(fact(5) == 120,		'729: fact(5) == 120');
	vrfy(frac(3) == 0,  		'730: frac(3) == 0');
	vrfy(frac(2/3) == 2/3,		'731: frac(2/3) == 2/3');
	vrfy(frac(17/3) == 2/3,		'732: frac(17/3) == 2/3');
	vrfy(gcd(0,3) == 3,		'733: gcd(0,3) == 3');
	vrfy(gcd(1,12) == 1,		'734: gcd(1,12) == 1');
	vrfy(gcd(11,7) == 1,		'735: gcd(11,7) == 1');
	vrfy(gcd(20,65) == 5,		'736: gcd(20,65) == 5');
	vrfy(gcdrem(20,3) == 20,	'737: gcdrem(20,3) == 20');
	vrfy(gcdrem(100,6) == 25,	'738: gcdrem(100,6) == 25');
	vrfy(highbit(1) == 0,		'739: highbit(1) == 0');
	vrfy(highbit(15) == 3,		'740: highbit(15) == 3');
	vrfy(hypot(3,4) == 5,		'741: hypot(3,4) == 5');
	vrfy(ilog(90,3) == 4,		'742: ilog(90,3) == 4');
	vrfy(ilog10(123) == 2, 		'743: ilog10(123) == 2');
	vrfy(ilog2(17) == 4,		'744: ilog2(17) == 4');
	vrfy(im(3) == 0,  		'745: im(3) == 0');
	vrfy(im(2+3i) == 3,		'746: im(2+3i) == 3');
	print				'747: test unused';
	print				'748: test unused';
	print				'749: test unused';
	print				'750: test unused';
	print				'751: test unused';
	print				'752: test unused';
	print				'753: test unused';
	print				'754: test unused';
	print				'755: test unused';
	print				'756: test unused';
	vrfy(int(5) == 5,   		'757: int(5) == 5');
	vrfy(int(19/3) == 6, 		'758: int(19/3) == 6');
	vrfy(inverse(3/2) == 2/3,	'759: inverse(3/2) == 2/3');
	vrfy(iroot(18,2) == 4, 		'760: iroot(18,2) == 4');
	vrfy(iroot(100,3) == 4, 	'761: iroot(100,3) == 4');
	vrfy(iseven(10) == 1, 		'762: iseven(10) == 1');
	vrfy(iseven(13) == 0, 		'763: iseven(13) == 0');
	vrfy(iseven('a') == 0, 		"764: iseven('a') == 0");
	vrfy(isint(7) == 1,  		'765: isint(7) == 1');
	vrfy(isint(19/2) == 0,		'766: isint(19/2) == 0');
	vrfy(isint('a') == 0,		"767: isint('a') == 0");
	vrfy(islist(3) == 0,		'768: islist(3) == 0');
	vrfy(islist(list(2,3)) == 1,	'769: islist(list(2,3)) == 1');
	vrfy(ismat(3) == 0,		'770: ismat(3) == 0');
	vrfy(ismult(7,3) == 0, 		'771: ismult(7,3) == 0');
	vrfy(ismult(15,5) == 1, 	'772: ismult(15,5) == 1');
	vrfy(isnull(3) == 0, 		'773: isnull(3) == 0');
	vrfy(isnull(null()) == 1, 	'774: isnull(null()) == 1');
	vrfy(isnum(2/3) == 1, 		'775: isnum(2/3) == 1');
	vrfy(isnum('xx') == 0, 		"776: isnum('xx') == 0");
	vrfy(isobj(3) == 0, 		'777: isobj(3) == 0');
	vrfy(isodd(7) == 1, 		'778: isodd(7) == 1');
	vrfy(isodd(8) == 0, 		'779: isodd(8) == 0');
	vrfy(isodd('x') == 0, 		"780: isodd('a') == 0");
	vrfy(isqrt(27) == 5, 		'781: isqrt(27) == 5');
	vrfy(isreal(3) == 1,		'782: isreal(3) == 1');
	vrfy(isreal('x') == 0,		"783: isreal('x') == 0");
	vrfy(isreal(2+3i) == 0,		'784: isreal(2+3i) == 0');
	vrfy(isstr(5) == 0,		'785: isstr(5) == 0');
	vrfy(isstr('foo') == 1,		"786: isstr('foo') == 1");
	vrfy(isrel(10,14) == 0,		'787: isrel(10,14) == 0');
	vrfy(isrel(15,22) == 1,		'788: isrel(15,22) == 1');
	vrfy(issimple(6) == 1,		'789: issimple(6) == 1');
	vrfy(issimple(3-2i) == 1,	'790: issimple(3-2i) == 1');
	vrfy(issimple(list(5)) == 0,	'791: issimple(list(5)) == 0');
	vrfy(issq(26) == 0,		'792: issq(26) == 0');
	vrfy(issq(9/4) == 1,		'793: issq(9/4) == 1');
	print				'794: test unused';
	vrfy(istype(9,4) == 1,		'795: istype(9,4) == 1');
	vrfy(istype(3,'xx') == 0,	"796: istype(3,'xx') == 0");
	vrfy(jacobi(5,11) == 1, 	'797: jacobi(2,7) == 1');
	vrfy(jacobi(6,13) == -1,	'798: jacobi(6,13) == -1');
	vrfy(lcm(3,4,5,6) == 60,	'799: lcm(3,4,5,6) == 60');
	vrfy(lcmfact(8) == 840,		'800: lcmfact(8) == 840');
	vrfy(lfactor(21,5) == 3,	'801: lfactor(21,5) == 3');
	vrfy(lfactor(97,20) == 1,	'802: lfactor(97,20) == 1');
	vrfy(lowbit(12) == 2,		'803: lowbit(12) == 2');
	vrfy(lowbit(17) == 0,		'804: lowbit(17) == 0');
	vrfy(ltol(1) == 0,		'805: ltol(1) == 0');
	vrfy(max(3,-9,7,4) == 7,	'806: max(3,-9,7,4) == 7');
	vrfy(meq(13,33,10) == 1,	'807: meq(13,33,10) == 1');
	vrfy(meq(7,19,11) == 0,		'808: meq(7,19,11) == 0');
	vrfy(min(9,5,12) == 5,		'809: min(9,5,12) == 5');
	vrfy(minv(13,97) == 15,		'810: minv(13,97) == 15');
	vrfy(mne(16,37,10) == 1,	'811: mne(16,37,10) == 1');
	vrfy(mne(46,79,11) == 0,	'812: mne(46,79,11) == 0');
	vrfy(norm(4) == 16,   		'813: norm(4) == 16');
	vrfy(norm(2-3i) == 13, 		'814: norm(2-3i) == 13');
	vrfy(num(7) == 7,   		'815: num(7) == 7');
	vrfy(num(11/4) == 11,		'816: num(11/4) == 11');
	vrfy(num(-9/5) == -9, 		'817: num(-9/5) == -9');
	vrfy(char(ord('a')+2) == 'c',	"818: char(ord('a')+2) == 'c'");
	vrfy(perm(7,3) == 210, 		'819: perm(7,3) == 210');
	vrfy(pfact(10) == 210, 		'820: pfact(10) == 210');
	vrfy(places(3/7) == -1,		'821: places(3/7) == -1');
	vrfy(places(.347) == 3,		'822: places(.347) == 3');
	vrfy(places(17) == 0,		'823: places(17) == 0');
	vrfy(pmod(3,36,37) == 1,	'824: pmod(3,36,37) == 1');
	vrfy(poly(2,3,5,2) == 19,	'825: poly(2,3,5,2) == 19');
	vrfy(ptest(101,10) == 1,	'826: ptest(101,10) == 1');
	vrfy(ptest(221,30) == 0,	'827: ptest(221,30) == 0');
	vrfy(re(9) == 9,       		'828: re(9) == 9');
	vrfy(re(-7+3i) == -7,  		'829: re(-7+3i) == -7');
	vrfy(scale(3,4) == 48, 		'830: scale(3,4) == 48');
	vrfy(sgn(-4) == -1,    		'831: sgn(-4) == -1');
	vrfy(sgn(0) == 0,      		'832: sgn(0) == 0');
	vrfy(sgn(3) == 1,      		'833: sgn(3) == 1');
	vrfy(size(7) == 1,     		'834: size(7) == 1');
	vrfy(sqrt(121) == 11,  		'835: sqrt(121) == 11');
	vrfy(ssq(2,3,4) == 29,		'836: ssq(2,3,4) == 29');
	vrfy(str(45) == '45',  		"837: str(45) == '45'");
	vrfy(strcat('a','bc','def')=='abcdef',
			       "838: strcat('a','bc','def')=='abcdef'");
	vrfy(strlen('') == 0, 		"839: strlen('') == 0");
	vrfy(strlen('abcd') == 4,	"840: strlen('abcd') == 4");
	vrfy(substr('abcd',2,1) == 'b',   "841: substr('abcd',2,1) == 'b'");
	vrfy(substr('abcd',3,4) == 'cd',  "842: substr('abcd',3,4) == 'cd'");
	vrfy(substr('abcd',1,3) == 'abc', "843: substr('abcd',1,3) == 'abc'");
	vrfy(xor(17,17) == 0,		'844: xor(17,17) == 0');
	vrfy(xor(12,5) == 9,		'845: xor(12,5) == 9');
	vrfy(mmin(3,7) == 3,		'846: mmin(3,7) == 3');
	vrfy(mmin(4,7) == -3,		'847: mmin(4,7) == -3');
	vrfy(digit(123,2) == 1,		'848: digit(123,2) == 1');
	vrfy(ismult(3/4, 1/7) == 0,	'849: ismult(3/4, 1/7) == 0');
	vrfy(gcd(3/4, 1/7) == 1/28,	'850: gcd(3/4,1/7) == 1/28');
	vrfy(gcd(2,3,1/2) == 1/2,	'851: gcd(2,3,1/2) == 1/2');
	vrfy(gcd(17,7,1/7) == 1/7,	'852: gcd(17,7,1/7) == 1/7');
	vrfy(gcd(2) == 2,		'853: gcd(2) == 2');
	vrfy(gcd(-2) == 2,		'854: gcd(-2) == 2');
	vrfy(floor(1.5) == 1,		'855: floor(1.5) == 1');
	vrfy(floor(.5) == 0,		'856: floor(.5) == 0');
	vrfy(floor(-.5) == -1,		'857: floor(-.5) == -1');
	vrfy(floor(-1.5) == -2,		'858: floor(-1.5) == -2');
	vrfy(ceil(1.5) == 2,		'859: ceil(1.5) == 2');
	vrfy(ceil(.5) == 1,		'860: ceil(.5) == 1');
	vrfy(ceil(-.5) == 0,		'861: ceil(-.5) == 0');
	vrfy(ceil(-1.5) == -1,		'862: ceil(-1.5) == -1');
	vrfy(frac(-7.2) == -.2,		'863: frac(-7.2) == -.2');
	vrfy(gcd(4, 5, 1/3) == 1/3,	'864: gcd(4, 5, 1/3) == 1/3');
	vrfy(ltol(7/25) == 24/25,	'865: ltol(7/25) == 24/25');
	vrfy(hmean(1,2,3) == 18/11,	'866: hmean(1,2,3) == 18/11');
	vrfy(ilog2(2^-20) == -20,	'867: ilog2(2^-20) == -20');
	vrfy(ord("DBell") == 68,	'868: ord("DBell") == 68');
	vrfy(cmp("a","b") == -1,	'869: cmp("a","b") == -1');
	vrfy(cmp("abcd","abc") == 1,	'870: cmp("abcd","abc") == 1');
	vrfy(cmp(3,4i) == 1-1i,		'871: cmp(3,4i) == 1-1i');
	vrfy(cmp(4,4i) == 1-1i,		'872: cmp(4,4i) == 1-1i');
	vrfy(cmp(5,4i) == 1-1i,		'873: cmp(5,4i) == 1-1i');
	vrfy(cmp(-5,4i) == -1-1i,	'874: cmp(-5,4i) == -1-1i');
	vrfy(cmp(-4i,5) == -1-1i,	'875: cmp(-4i,5) == -1-1i');
	vrfy(cmp(-4i,-5) == 1-1i,	'876: cmp(-4i,-5) == 1-1i');
	vrfy(cmp(3i,4i) == -1i,		'877: cmp(3i,4i) == -1i');
	vrfy(cmp(4i,4i) == 0,		'878: cmp(4i,4i) == 0');
	vrfy(cmp(5i,4i) == 1i,		'879: cmp(5i,4i) == 1i');
	vrfy(cmp(3+4i,5) == -1+1i,	'880: cmp(3+4i,5) == -1+1i');
	vrfy(cmp(3+4i,-5) == 1+1i,	'881: cmp(3+4i,-5) == 1+1i');
	vrfy(cmp(3+4i,3+4i) == 0,	'882: cmp(3+4i,3+4i) == 0');
	vrfy(cmp(3+4i,3-4i) == 1i,	'883: cmp(3+4i,3-4i) == 1i');
	vrfy(cmp(3+4i,2+3i) == 1+1i,	'884: cmp(3+4i,2+3i) == 1+1i');
	vrfy(cmp(3+4i,-4-5i) == 1+1i,	'885: cmp(3+4i,-4-5i) == 1+1i');
	vrfy(comb(7,0) == 1,		'886: comb(7,0) == 1');
	vrfy(comb(0,0) == 1,		'887: comb(0,0) == 1');
	vrfy(perm(7,0) == 7,		'888: perm(7,0) == 7');
	vrfy(perm(0,0) == 0,		'889: perm(0,0) == 0');
	vrfy(isfile(files(0)) == 1,	'890: isfile(files(0)) == 1');
	vrfy(isfile(0) == 0,		'891: isfile(0) == 0');
	vrfy(ismult(4^67, 2^59) == 1,	'892: ismult(4^67, 2^59) == 1');
	vrfy(ismult(13, 4/67) == 0,	'893: ismult(13, 4/67) == 0');
	vrfy(ismult(13, 7/56) == 1,	'894: ismult(13, 7/56) == 1');
	vrfy(isnum(2i) == 1,		'895: isnum(2i) == 1');
	vrfy(iseven(1/3) == 0,		'896: iseven(1/3) == 0');
	vrfy(isodd(1/3) == 0,		'897: isodd(1/3) == 0');
	vrfy(isrel(-5, 6) == 1,		'898: isrel(-5, 6) == 1');
	vrfy(isrel(-2, 6) == 0,		'899: isrel(-2, 6) == 0');
	vrfy(isset(9,0) == 1,		'900: isset(9,0) == 1');
	vrfy(isset(9,1) == 0,		'901: isset(9,1) == 0');
	vrfy(isset(9,2) == 0,		'902: isset(9,2) == 0');
	vrfy(isset(9,3) == 1,		'903: isset(9,3) == 1');
	vrfy(isset(1.25, -2) == 1,	'904: isset(1.25, -2) == 1');
	vrfy(isset(1.25, -1) == 0,	'905: isset(1.25, -1) == 0');
	vrfy(isset(1.25, 0) == 1,	'906: isset(1.25, 0) == 1');
	vrfy(isset(pi(), 1) == 1,	'907: isset(pi(), 1) == 1');
	vrfy(isset(pi(), -2) == 0,	'908: isset(pi(), -2) == 0');
	vrfy(isset(pi(), -3) == 1,	'909: isset(pi(), -3) == 1');
	vrfy(istype(2, 3.0) == 1,	'910: istype(2, 3.0) == 1');
	vrfy(istype(2, "2") == 0,	'911: istype(2, "2") == 0');
	vrfy(istype(2, 3i) == 0,	'912: istype(2, 3i) == 0');
	vrfy(istype(2i+2, 3i) == 1,	'913: istype(2i+2, 3i) == 1');
	a = epsilon();
	print 				'914: a = epsilon()';
	vrfy(epsilon(a) == epsilon(),	'915: epsilon(a) == epsilon()');
	vrfy(epsilon(a) == epsilon(),	'916: epsilon(a) == epsilon()');
	vrfy(epsilon(a) == epsilon(),	'917: epsilon(a) == epsilon()');
	vrfy(epsilon() == a,		'918: epsilon() == a');
	b = 1e-6;
	print				'919: b = 1e-6';
	vrfy(epsilon(b) == a,		'920: epsilon(b) == a');
	vrfy(epsilon(b) == epsilon(),	'921: epsilon(b) == epsilon()');
	vrfy(epsilon(b) == epsilon(),	'922: epsilon(b) == epsilon()');
	vrfy(epsilon(b) == epsilon(),	'923: epsilon(b) == epsilon()');
	vrfy(epsilon() == 1e-6,		'924: epsilon() == 1e-6');
	vrfy(epsilon(a) == b,		'925: epsilon(a) == b');
	vrfy(epsilon(a) == epsilon(),	'926: epsilon(a) == epsilon()');
	vrfy(epsilon(a) == epsilon(),	'927: epsilon(a) == epsilon()');
	vrfy(epsilon(a) == epsilon(),	'928: epsilon(a) == epsilon()');
	vrfy(epsilon(a) == a,		'929: epsilon(a) == a');
	vrfy(quomod(13,5,a,b) == 1,	'930: quomod(13,5,a,b) == 1');
	vrfy(a == 2,			'931: a == 2');
	vrfy(b == 3,			'932: b == 3');
	vrfy(quomod(15.6,5.2,a,b) == 0, '933: quomod(15.6,5.2,a,b) == 0');
	vrfy(a == 3,			'934: a == 3');
	vrfy(b == 0,			'935: b == 0');
	vrfy(putenv("abcd=efg") == 0,	'936: putenv("abcd=efg")');
	vrfy(getenv("abcd") == "efg",	'937: getenv("abcd") == "efg"');
	vrfy(putenv("abcd","123")==0,	'938: putenv("abcd","123")');
	vrfy(getenv("abcd") == "123",	'939: getenv("abcd") == "123"');
	vrfy(isnull(getenv("notavar")) == 1,
					'940: isnull(getenv("notavar")) == 1');
	a = "abcdefg";
	print				'941: a = "abcdefg"';
	vrfy(strpos(a, "c") == 3,	'942: strpos(a, "c") == 3');
	vrfy(strpos(a, "def") == 4,	'943: strpos(a, "def") == 4');
	vrfy(strpos(a, "defg") == 4,	'944: strpos(a, "defg") == 4');
	vrfy(strpos(a, "defgh") == 0,	'945: strpos(a, "defgh") == 0');
	vrfy(strpos(a, "abc") == 1,	'946: strpos(a, "abc") == 1');
	vrfy(strpos(a, "xyz") == 0,	'947: strpos(a, "xyz") == 0');
	vrfy(strpos(a, a) == 1,		'948: strpos(a, a) == 1');
	vrfy(system("") == 0,		'949: system("") == 0');
	vrfy(system("true") == 0,	'950: system("true") == 0');
	vrfy(isatty(files(0)) == 1,	'951: isatty(files(0)) == 1');
	print				'952: test removed';
	print				'953: test removed';
	vrfy(isstr(cmdbuf()) == 1,	'954: isstr(cmdbuf()) == 1');
	vrfy(abs(root(4,3,0.1)-1.5874) < 0.1,
			'955: abs(root(4,3,0.1)-1.5874) < 0.1');
	print		'956: a = 2^300 + 69962309754533779525365054067';
	a = 2^300 + 69962309754533779525365054067;
	a /= 2^211;
	print				'957: a /= 2^211';
	vrfy(appr(a, 1e-20) == 2^89,	'958: appr(a, 1e-20) == 2^89');
	vrfy(digits(5e149) == 150,	'959: digits(5e149) == 150');
	vrfy(highbit(2) == 1,		'960: highbit(2) == 1');
	vrfy(highbit(3) == 1,		'961: highbit(3) == 1');
	vrfy(highbit(4) == 2,		'962: highbit(4) == 2');
	vrfy(highbit(-15) == 3,		'963: highbit(-15) == 3');
	vrfy(highbit(2^27) == 27,	'964: highbit(2^27) == 27');
	a = 12.34;
	print				'965: a = 12.34';
	vrfy(digit(a,2) == 0,		'966: digit(a,2) == 0');
	vrfy(digit(a,1) == 1,		'967: digit(a,1) == 1');
	vrfy(digit(a,0) == 2,		'968: digit(a,0) == 2');
	vrfy(digit(a,-1) == 3,		'969: digit(a,-1) == 3');
	vrfy(digit(a,-2) == 4,		'970: digit(a,-2) == 4');
	a = 10/7;
	print				'971: a = 10/7';
	vrfy(digit(a,1) == 0,		'972: digit(a,1) == 0');
	vrfy(digit(a,0) == 1,		'973: digit(a,0) == 1');
	vrfy(digit(a,-1) == 4,		'974: digit(a,-1) == 4');
	vrfy(digit(a,-2) == 2,		'975: digit(a,-2) == 2');
	vrfy(digit(a,-3) == 8,		'976: digit(a,-3) == 8');
	vrfy(digits(0) == 1,		'977: digits(0) == 1');
	vrfy(digits(0.0123) == 1,	'978: digits(0.0123) == 1');
	vrfy(digits(3.7) == 1,		'979: digits(3.7) == 1');
	vrfy(digits(-27) == 2,		'980: digits(-27) == 2');
	vrfy(digits(-99.7) == 2,	'981: digits(-99.7) == 2');
	vrfy(ilog2(1) == 0,		'982: ilog2(1) == 0');
	vrfy(ilog2(2) == 1,		'983: ilog2(2) == 1');
	vrfy(ilog2(3) == 1,		'984: ilog2(3) == 1');
	vrfy(ilog2(4) == 2,		'985: ilog2(4) == 2');
	vrfy(ilog2(1/15) == -4,		'986: ilog2(1/15) == -4');
	vrfy(places(3) == 0,		'987: places(3) == 0');
	vrfy(places(0.0123) == 4,	'988: places(0.0123) == 4');
	vrfy(places(3.70) == 1,		'989: places(3.70) == 1');
	vrfy(places(1e-10) == 10,	'990: places(1e-10) == 10');
	vrfy(places(3/7) == -1,		'991: places(/37) == -1');
	vrfy(ilog10(7.7) == 0,		'992: ilog10(7.7) == 0');
	vrfy(ilog10(77.7) == 1,		'993: ilog10(77.7) == 1');
	vrfy(ilog10(777) == 2,		'994: ilog10(777) == 2');
	vrfy(ilog10(.00777) == -3,	'995: ilog10(.00777) == -3');
	vrfy(ilog10(1e27) == 27,	'996: ilog10(1e27) == 27');
	vrfy(lowbit(2) == 1,		'997: lowbit(2) == 1');
	vrfy(lowbit(3) == 0,		'998: lowbit(3) == 0');
	vrfy(lowbit(4) == 2,		'999: lowbit(4) == 2');
	vrfy(lowbit(-15) == 0,		'1000: lowbit(-15) == 0');
	vrfy(lowbit(2^27) == 27,	'1001: lowbit(2^27) == 27');
	vrfy(char(0102) == 'B',		'1002: char(0102) == \'B\'');
	vrfy(char(0x6f) == 'o',		'1003: char(0x6f) == \'o\'');
	vrfy(char(119) == 'w',		'1004: char(119) == \'w\'');
	vrfy(char(0145) == 'e',		'1005: char(0145) == \'e\'');
	vrfy(char(0x6e) == 'n',		'1006: char(0x6e) == \'n\'');
	vrfy(den(-1.25) == 4,		'1007: den(-1.25) == 4');
	vrfy(den(121/33) == 3,		'1008: den(121/33) == 3');
	vrfy(gcd(9/10, 11/5, 4/25) == 0.02,
					'1009: gcd(9/10, 11/5, 4/25) == 0.02');
	vrfy(gcd(0,0,0,0,0) == 0,	'1010: gcd(0,0,0,0,0) == 0');
	vrfy(hypot(3, 4, 1e-6) == 5,	'1011: hypot(3, 4, 1e-6) == 5');
	vrfy(hypot(2,-3,1e-6) == 3605551/1e6,
				'1012: hypot(2,-3,1e-6) == 3605551/1e6');
	vrfy(im(-4.25 - 7i) == -7,	'1013: im(-4.25 - 7i) == -7');
	vrfy(lcm(12, -24, 30) == -120,'1014: lcm(12, -24, 30) == -120');
	vrfy(lcm(9/10, 11/5, 4/25) == 79.2,
				'1015: lcm(9/10, 11/5, 4/25) == 79.2');
	vrfy(lcm(2) == 2,		'1016: lcm(2) == 2');
	vrfy(max(2) == 2,		'1017: max(2) == 2');
	vrfy(min(2) == 2,		'1018: min(2) == 2');
	vrfy(re(-4.25 - 7i) == -4.25,	'1019: re(-4.25 - 7i) == -4.25');
	vrfy(size("abc") == 3,		'1020: size("abc") == 3');
	vrfy(str("") == "",		'1021: str("") == ""');
	vrfy(str(null()) == "",		'1022: str(null()) == ""');
	vrfy(str("Ernest Bowen") == "Ernest Bowen",
				'1023: str("Ernest Bowen") == "Ernest Bowen"');
	vrfy(strlen("a b\tc\\d") == 7,
					'1024: strlen("a b\tc\\d") == 7');
	vrfy(xor(2) == 2,		'1025: xor(2) == 2');
	vrfy(xor(5, 3, -7, 2, 9) == 10,
					'1026: xor(5, 3, -7, 2, 9) == 10');
	vrfy(xor(0,0) == 0,		'1027: xor(0,0) == 0');
	vrfy(xor(0,1) == 1,		'1028: xor(0,1) == 1');
	vrfy(xor(1,0) == 1,		'1029: xor(1,0) == 1');
	vrfy(xor(1,1) == 0,		'1030: xor(1,1) == 0');
	vrfy(xor(5,3,-7,2,9) == 10,	'1031: xor(5,3,-7,2,9) == 10');
	vrfy(fib(-2) == -1,		'1032: fib(-2) == -1');
	vrfy(fib(-1) == 1,		'1033: fib(-1) == 1');
	vrfy(fib(-10) == -55,		'1034: fib(-10) == -55');
	vrfy(ilog(1/8, 3) == -2,	'1035: ilog(1/8, 3) == -2');
	vrfy(ilog(8.9, 3) == 1,	'1036: ilog(8.9, 3) == 1');
	vrfy(iroot(1,9) == 1,		'1037: iroot(1,9) == 1');
	vrfy(iroot(pi()^8,5) == 6,	'1038: iroot(pi()^8,5)');
	vrfy(isqrt(8.5) == 2,		'1039: isqrt(8.5) == 2');
	vrfy(isqrt(2e56) == 14142135623730950488016887242,
			'1040: isqrt(2e56) == 14142135623730950488016887242');
	vrfy(near(22/7, 3.15, .01) == -1,
			'1041: near(22/7, 3.15, .01) == -1');
	vrfy(near(22/7, 3.15, .005) == 1,
			'1042: near(22/7, 3.15, .005) == 1');
	vrfy(norm(3.4) == 11.56,	'1043: isqrt(3.4) == 11.56');
	vrfy(pi(1e-5) == 3.14159,	'1044: pi(1e-5) == 3.14159');
	pi = pi(1e-10);
	print				'1045: pi = pi(1e-10)';
	vrfy(pi == 3.1415926536,	'1046: pi == 3.1415926536');
	vrfy(polar(2,pi/2,1e-5)==2i,	'1047: polar(2,pi/2,1e-5)==2i');
	vrfy(power(exp(1,1e-20),pi(1e-20)*1i/2,1e-20) == 1i,
			'1048: power(exp(1,1e-20),pi(1e-20)*1i/2,1e-20) == i1');
	vrfy(ssq(1+2i, 3-4i, 5 +6i) == -21+40i,
			'1049: ssq(1+2i, 3-4i, 5 +6i) == -21+40i');
	vrfy(isreal(ln(1 + 1e-10i, 1e-5)),
			'1050: isreal(ln(1 + 1e-10i, 1e-5))');
	vrfy(isreal(exp(pi(1e-10)*1i, 1e-5)),
			'1051: isreal(exp(pi(1e-10)*1i, 1e-5))');
	vrfy(cfappr(43/30, 10, 0) == 10/7,
			'1052: cfappr(43/30, 10, 0) == 10/7');
	vrfy(cfappr(43/30, 10, 1) == 13/9,
			'1053: cfappr(43/30, 10, 1) == 13/9');
	vrfy(cfappr(43/30, 10, 16) == 10/7,
			'1054: cfappr(43/30, 10, 16) == 10/7');
	vrfy(cfappr(6/5, 1/2, 16) == 1,
			'1055: cfappr(6/5, 1/2, 16) == 1');
	vrfy(cfsim(13,8) == 0,		'1056: cfsim(13,8) == 0');
	vrfy(cfsim(1057,8) == 0,	'1057: cfsim(1057,8) == 0');
	vrfy(mod(11,5,0) == 1,		'1058: mod(11,5,0) == 1');
	vrfy(mod(11,5,1) == -4,		'1059: mod(11,5,1) == -4');
	vrfy(mod(-11,5,2) == -1,	'1060: mod(-11,5,2) == -1');
	vrfy(mod(-11,-5,3) == 4,	'1061: mod(-11,-5,3) == 4');
	vrfy(mod(12.5,5,16) == 2.5,	'1062: mod(12.5,5,16) == 2.5');
	vrfy(mod(12.5,5,17) == -2.5,	'1063: mod(12.5,5,17) == -2.5');
	vrfy(mod(12.5,5,24) == 2.5,	'1064: mod(12.5,5,24) == 2.5');
	vrfy(mod(-7.5,-5,24) == 2.5,	'1065: mod(-7.5,-5,24) == 2.5');
	vrfy(quo(11,5,0) == 2,		'1066: quo(11,5,0) == 2');
	vrfy(quo(11,5,1) == 3,		'1067: quo(11,5,1) == 3');
	vrfy(quo(-11,5,2) == -2,	'1068: quo(-11,5,2) == -2');
	vrfy(quo(-11,-5,3) == 3,	'1069: quo(-11,-5,3) == 3');
	vrfy(quo(12.5,5,16) == 2,	'1070: quo(12.5,5,16) == 2');
	vrfy(quo(12.5,5,17) == 3,	'1071: quo(12.5,5,17) == 3');
	vrfy(quo(12.5,5,24) == 2,	'1072: quo(12.5,5,24) == 2');
	vrfy(quo(-7.5,-5,24) == 2,	'1073: quo(-7.5,-5,24) == 2');
	vrfy(frac(2.5 + 3i) == .5,	'1074: frac(2.5 + 3i) == .5');
	vrfy(root(1i,1000,1e-2)==1,	'1075: root(1i,1000,1e-2) == 1');
	vrfy(scale(2+3i,2)==8+12i,	'1076: scale(2+3i,2) == 8+12i');
	vrfy(frem(8,4) == 2,		'1077: frem(8,4) == 2');
	vrfy(jacobi(80,199) == 1,	'1078: jacobi(80,199) == 1');

	print '1079: Ending test_functions';

	print;
	print '1100: reserved for future expansion of test_functions';
}
print '017: parsed test_functions()';


/*
 * _test_underscore - test use of _'s in identifiers
 */
_ = 49;
print '018: _ = 49';
__ = 63;
print "019: __ = 63";
define _test_underscore()
{
	local _a = 27;
	local __a = 23209;

	print "1200: Beginning _test_underscore";

	vrfy(_a == 27,			    '1201: _a == 27');
	vrfy(_ == 49,			    '1202: _ == 49');
	vrfy(__ == 63,			    '1203: __ == 63');
	vrfy(__a == 23209,		    '1204: __a == 23209');

	print "1205: Ending _test_underscore";
}
print '020: parsed _test_underscore';


/*
 * place holder for any print items
 */
print "021:", "reserved for future use";
print "022:": " reserved for future use";


/*
 * Test associations
 */
define test_assoc()
{
	static a;
	static b;
	local A;

	print '1300: Beginning associations test';

	a = assoc();
	vrfy(size(a) == 0,		'1301: size(a) == 0');
	a["curds"] = 13;
	print				'1302: a["curds"] = 13';
	vrfy(a["curds"] == 13,	'1303: a["curds"] == 13');
	a[13] = 17;
	print				'1304: a[13] = 17';
	vrfy(a[13] == 17,		'1305: a[13] == 17');
	vrfy(a[a["curds"]] == 17,	'1306: a[a["curds"]] == 17');
	a[17] = 19;
	print				'1307: a[17] = 19';
	vrfy(a[17] == 19,		'1308: a[17] == 19');
	vrfy(a[a["curds"]+4] == 19,	'1309: a[a["curds"]+4] == 19');
	vrfy(size(a) == 3,		'1310: size(a) == 3');
	vrfy(a[[search(a,17)]] == 17,	'1311: (a[[search(a,17)]] == 17');
	vrfy(isnull(search(a,16)),	'1312: isnull(search(a,16))');
	a["curds","whey"] = "spider";
	print				'1313: a["curds","whey"] = "spider"';
	vrfy(a["curds","whey"] == "spider", '1314: a["curds","whey"] == "spider"');
	vrfy(a[[rsearch(a,"spider")]] == "spider", '1315: a[[search(a,"spider")]] == "spider"');
	b = a;
	print				'1316: b = a';
	vrfy(b[17] == 19,		'1317: b[17] == 19');
	vrfy(a == b,			'1318: a == b');
	vrfy(isassoc(a) == 1,		'1319: isassoc(a) == 1');
	vrfy(isassoc(1) == 0,		'1320: isassoc(1) == 0');
	A = assoc();
	vrfy(quomod(13, 5, A[1], A[2]) == 1,
					'1321: quomod(13, 5, A[1], A[2]) == 1');
	vrfy(A[1] == 2,		'1322: A[1] == 2');
	vrfy(A[2] == 3,		'1323: A[2] == 3');

	print '1324: Ending associations test';
}
print '023: parsed test_assoc()';


/*
 * Test lists
 */
define test_list()
{
	static a;
	static b;
	static x = list(11,13,17,23,29);
	static y0 = list(1,3,7,3,9);
	static y1 = list(-9,-7,-3,-7,-1);
	static y2 = list(-9,-7,-3,3,9);
	static y3 = list(1,3,7,-7,-1);
	static y4 = list(1,3,-3,3,-1);
	local A,B,C,D,E;
	local y,z;
	local list1, list2;

	print '1400: Beginning list test';

	a = list(2,3,5);
	vrfy(a == list(2,3,5),		'1401: a == list(2,3,5)');
	vrfy(a[[0]] == 2,		'1402: a[[0]] == 2');
	vrfy(a[[1]] == 3,		'1403: a[[1]] == 3');
	vrfy(a[[2]] == 5,		'1404: a[[2]] == 5');
	vrfy(size(a) == 3,		'1405: size(a) == 3');
	vrfy(search(a,3) == 1,		'1406: search(a,3) == 1');
	vrfy(isnull(search(a,3,2)),	'1407: isnull(search(a,3,2))');
	vrfy(rsearch(a,3,2) == 1,	'1408: rsearch(a,3,2) == 1');
	push(a,7);
	print 				'1409: push(a,7)';
	vrfy(search(a,7) == 0,		'1410: search(a,7) == 0');
	vrfy(pop(a) == 7,		'1411: pop(a) == 7');
	vrfy(size(a) == 3,		'1412: size(a) == 3');
	append(a,7);
	print				'1413: append(a,7)';
	vrfy(search(a,7) == 3,		'1414: search(a,7) == 3');
	vrfy(size(a) == 4,		'1415: size(a) == 4');
	vrfy(remove(a) == 7,		'1416: remove(a) == 7');
	vrfy(size(a) == 3,		'1417: size(a) == 3');
	b = a;
	print				'1418: b = a';
	insert(a,1,7);
	print				'1419: insert(a,1,7)';
	vrfy(search(a,2) == 0,		'1420: search(a,2) == 0');
	vrfy(search(a,7) == 1,		'1421: search(a,7) == 1');
	vrfy(search(a,3) == 2,		'1422: search(a,3) == 2');
	vrfy(search(a,5) == 3,		'1423: search(a,5) == 3');
	vrfy(size(a) == 4,		'1424: size(a) == 4');
	vrfy(delete(a,1) == 7,		'1425: remove(a) == 7');
	vrfy(search(a,2) == 0,		'1426: search(a,2) == 0');
	vrfy(search(a,3) == 1,		'1427: search(a,3) == 1');
	vrfy(search(a,5) == 2,		'1428: search(a,5) == 2');
	vrfy(size(a) == 3,		'1429: size(a) == 3');
	vrfy(a == b,			'1430: a == b');
	A = list(1,2,3);
	print				'1431: A = list(1,2,3)';
	B = list(4,5);
	print				'1432: B = list(4,5)';
	C = join(A,B);
	print				'1433: C = join(A,B)';
	D = list(1,2,3,4,5);
	print				'1434: D = list(1,2,3,4,5)';
	vrfy(C == D,			'1435: C == D');
	E = list(5,4,3,2,1);
	print				'1436: E = list(5,4,3,2,1)';
	vrfy(reverse(D) == E,		'1437: reverse(D) == E');
	vrfy(sort(list(1,3,5,2,4))==D,'1438: sort(list(1,3,5,2,4))==D');
	vrfy(head(D,2) == list(1,2),	'1439: head(D,2) == list(1,2)');
	vrfy(head(D,-2)==list(1,2,3),	'1440: head(D,-2)==list(1,2,3)');
	vrfy(head(D,5) == D,		'1441: head(D,5) == D');
	vrfy(head(D,6) == D,		'1442: head(D,6) == D');
	vrfy(head(D,-5) == list(),	'1443: head(D,-5) == list()');
	vrfy(head(D,-6) == list(),	'1444: head(D,-6) == list()');
	vrfy(tail(E,2) == list(2,1),	'1445: tail(E,2) == list(2,1)');
	vrfy(tail(E,-2)==list(3,2,1),	'1446: tail(E,-2)==list(3,2,1)');
	vrfy(tail(E,5) == E,		'1447: tail(E,5) == E');
	vrfy(tail(E,6) == E,		'1448: tail(E,6) == E');
	vrfy(tail(E,-5) == list(),	'1449: tail(E,-5) == list()');
	vrfy(tail(E,-6) == list(),	'1450: tail(E,-6) == list()');
	vrfy(segment(D,1,3) == list(2,3,4),
					'1451: segment(D,1,3) == list(2,3,4)');
	vrfy(segment(D,3,1) == list(4,3,2),
					'1452: segment(D,3,1) == list(4,3,2)');
	vrfy(segment(D,0,2) == head(D,3),
					'1453: segment(D,0,2) == head(D,3)');
	vrfy(segment(D,2,0) == tail(E,3),
					'1454: segment(D,2,0) == tail(E,3)');
	vrfy(segment(D,0,4) == head(D,5),
					'1455: segment(D,0,4) == head(D,5)');
	vrfy(segment(D,4,0) == head(E,5),
					'1456: segment(D,4,0) == head(E,5)');
	vrfy(segment(D,3,4) == tail(D,2),
					'1457: segment(D,3,4) == tail(D,2)');
	vrfy(segment(D,4,3) == head(E,2),
					'1458: segment(D,4,3) == head(E,2)');
	for (y=0; y < size(D); ++y) {
	    for (z=y; z < size(D); ++z) {
		if (D != join(head(D,y), segment(D,y,z), tail(D,size(D)-z-1))) {
		    err(strcat("join loop failed at y=",str(y)," z=",str(z)));
		}
	    }
	}
	print				'1459: join loop test';
	vrfy(mod(x,10,0) == y0,		'1460: mod(x,10,0) == y0');
	vrfy(mod(x,10,1) == y1,		'1461: mod(x,10,1) == y1');
	vrfy(mod(x,10,2) == y0,		'1462: mod(x,10,2) == y0');
	vrfy(mod(x,10,3) == y1,		'1463: mod(x,10,3) == y1');
	vrfy(mod(x,10,4) == y0,		'1464: mod(x,10,4) == y0');
	vrfy(mod(x,10,5) == y1,		'1465: mod(x,10,5) == y1');
	vrfy(mod(x,10,6) == y0,		'1466: mod(x,10,6) == y0');
	vrfy(mod(x,10,7) == y1,		'1467: mod(x,10,7) == y1');
	vrfy(mod(x,10,8) == y2,		'1468: mod(x,10,8) == y2');
	vrfy(mod(x,10,9) == y3,		'1469: mod(x,10,9) == y3');
	vrfy(mod(x,10,10) == y2,	'1470: mod(x,10,10) == y2');
	vrfy(mod(x,10,11) == y3,	'1471: mod(x,10,11) == y3');
	vrfy(mod(x,10,12) == y2,	'1472: mod(x,10,12) == y2');
	vrfy(mod(x,10,13) == y3,	'1473: mod(x,10,13) == y3');
	vrfy(mod(x,10,14) == y2,	'1474: mod(x,10,14) == y2');
	vrfy(mod(x,10,15) == y3,	'1475: mod(x,10,15) == y3');
	vrfy(mod(x,10,16) == y4,	'1476: mod(x,10,16) == y4');
	vrfy(mod(x,10,16) == y4,	'1477: mod(x,10,16) == y4');
	vrfy(mod(x,10,18) == y4,	'1478: mod(x,10,18) == y4');
	vrfy(mod(x,10,19) == y4,	'1479: mod(x,10,18) == y4');
	vrfy(mod(x,10,20) == y4,	'1480: mod(x,10,20) == y4');
	vrfy(mod(x,10,21) == y4,	'1481: mod(x,10,21) == y4');
	vrfy(mod(x,10,22) == y4,	'1482: mod(x,10,22) == y4');
	vrfy(mod(x,10,23) == y4,	'1483: mod(x,10,23) == y4');
	vrfy(mod(x,10,24) == y4,	'1484: mod(x,10,24) == y4');
	vrfy(mod(x,10,25) == y4,	'1485: mod(x,10,25) == y4');
	vrfy(mod(x,10,26) == y4,	'1486: mod(x,10,26) == y4');
	vrfy(mod(x,10,27) == y4,	'1487: mod(x,10,27) == y4');
	vrfy(mod(x,10,28) == y4,	'1488: mod(x,10,28) == y4');
	vrfy(mod(x,10,29) == y4,	'1489: mod(x,10,29) == y4');
	vrfy(mod(x,10,30) == y4,	'1490: mod(x,10,30) == y4');
	vrfy(mod(x,10,31) == y4,	'1491: mod(x,10,31) == y4');
	list1 = list(3,1,"x",2,null());
	print				'1492: list1 = list(3,1,"x",2,null())';
	list2 = list(null(),1,2,3,"x");
	print				'1493: list2 = list(null(),1,2,3,"x")';
	vrfy(sort(list1) == list2,	'1494: sort(list1) == list2');

	print '1495: Ending list test';
}
print '024: parsed test_list()';


/*
 * Test rand
 */
define test_rand()
{
	local init;		/* initial generator state */
	local state0;		/* a generator state */
	local state1;		/* a generator state */
	local state2;		/* a generator state */
	local tmp;
	local n;

	print '1500: Beginning rand test';

	/* test save and restore of the initial state */
	tmp = srand(0);
	print				  '1501: tmp = srand(0)';
	init = srand();
	print				  '1502: init = srand()';
	state0 = srand(0);
	print				  '1503: state0 = srand(0)';
	vrfy(state0 == init,		  '1504: state0 == init');

	/* test the additive 55 shuffle generator */
	tmp = srand(0);
	print				  '1505: tmp = srand(0)';
	vrfy(rand() == 0xc79ef743e2e6849c, \
		  '1506: rand() == 0xc79ef743e2e6849c');
	vrfy(rand() == 0x8d2dcb2bed321284, \
		  '1507: rand() == 0x8d2dcb2bed321284');
	tmp = srand(init);
	print				  '1508: tmp = srand(init)';
	vrfy(rand() == 0xc79ef743e2e6849c, \
		  '1509: rand() == 0xc79ef743e2e6849c');
	vrfy(rand() == 0x8d2dcb2bed321284, \
		  '1510: rand() == 0x8d2dcb2bed321284');

	/* test range interface */
	tmp = srand(0);
	print				  '1511: tmp = srand(0)';
	vrfy(rand(12345678901234567890) == 0x8d2dcb2bed321284, \
		  '1512: rand(12345678901234567890) == 0x8d2dcb2bed321284');
	vrfy(rand(216091) == 0x13d2b,	  '1513: rand(216091) == 0x13d2b');
	vrfy(rand(100) == 0x26,	  '1514: rand(100) == 0x26');
	vrfy(rand(-46,46) == -0xf,	  '1515: rand(-46,46) == -0xf');
	tmp = srand(0);
	print				  '1516: tmp = srand(0)';
	vrfy(rand(2^64) == 0xc79ef743e2e6849c, \
		  '1517: rand(2^64) == 0xc79ef743e2e6849c');
	vrfy(rand(0,2^64) == 0x8d2dcb2bed321284, \
		  '1518: rand(0,2^64) == 0x8d2dcb2bed321284');

	/* test different forms of seeding the initial state */
	tmp = srand(0);
	print				  '1519: tmp = srand(0)';
	vrfy(srand() == init,		  '1520: srand() == init');
	tmp = srand(0x87e6ec938ff55aa5<<64);
	print	  '1521: tmp = srand(0x87e6ec938ff55aa5<<64)';
	vrfy(srand() == init,	  	  '1522: srand() == init');
	tmp = srand(state0);
	print				  '1523: tmp = srand(state0)';
	vrfy(srand() == init,		  '1524: srand() == init');
	tmp = srand(init);
	print				  '1525: tmp = srand(init)';
	vrfy(srand() == init,		  '1526: srand() == init');
	vrfy(tmp == init,		  '1527: tmp == init');

	/* test the bit length interface */
	tmp = srand(0);
	print				  '1528: tmp = srand(0)';
	vrfy(randbit(64) == 0xc79ef743e2e6849c, \
		  '1529: randbit(64) == 0xc79ef743e2e6849c');
	vrfy(randbit(128) == 0x8d2dcb2bed3212844f4ad31f3818af34, \
		  '1530: randbit(128) == 0x8d2dcb2bed3212844f4ad31f3818af34');
	vrfy(randbit(64) == 0x23a252f60bae4907, \
		  '1531: randbit(64) == 0x23a252f60bae4907');
	vrfy(randbit(128) == 0xa8ed5b6203e2b1da32848cd9b3f1e3fa, \
		  '1532: randbit(128) == 0xa8ed5b6203e2b1da32848cd9b3f1e3fa');
	tmp = srand(0);
	print				  '1533: tmp = srand(0)';
	vrfy(randbit(32) == 0xc79ef743,	  '1534: randbit(64) == 0xc79ef743');
	vrfy(randbit(32) == 0xe2e6849c,	  '1535: randbit(64) == 0xe2e6849c');
	vrfy(randbit(1) == 0x1,	 	  '1536: randbit(1) == 0x1');
	vrfy(randbit(5) == 0x3,	 	  '1537: randbit(5) == 0x3');
	vrfy(randbit(33) == 0x96e595f6,   '1538: randbit(33) == 0x96e595f6');
	vrfy(randbit(25) == 0x1321284,    '1539: randbit(25) == 0x1321284');
	vrfy(randbit(2) == 0x1,		  '1540: randbit(2) == 0x1');
	vrfy(randbit(13) == 0x7a5,	  '1541: randbit(13) == 0x7a5');
	vrfy(randbit(18) == 0x1a63e,	  '1542: randbit(19) == 0x1a63e');
	vrfy(randbit(8) == 0x70,	  '1543: randbit(8) == 0x70');
	vrfy(randbit(9) == 0x62,	  '1544: randbit(9) == 0x62');
	vrfy(randbit(70) == 0x2f3423a252f60bae49, \
		  '1545: randbit(70) == 0x2f3423a252f60bae49');
	print				  '1546: test unused';
	vrfy(randbit(8) == 0x7,		  '1547: randbit(8) == 0x7');
	vrfy(randbit(65) == 0x151dab6c407c563b4, \
		  '1548: randbit(65) == 0x151dab6c407c563b4');
	vrfy(randbit(63) == 0x32848cd9b3f1e3fa, \
		  '1549: randbit(63) == 0x32848cd9b3f1e3fa');

	/* check to be sure that the srand(1) bug was fixed */
	tmp = srand(1);
	print				  '1550: tmp = srand(1)';
	n = 1;
	print				  '1551: n = 1';
	vrfy(num(n),			  '1552: num(n)');
	vrfy(den(n),			  '1553: den(n)');
	vrfy(randbit(64) == 0x4280429f8069cb27, \
		  '1554: randbit(64) == 0x4280429f8069cb27');

	/* test randbit skip interface */
	tmp = srand(0);
	print				  '1555: tmp = srand(0)';
	vrfy(randbit(20) == 817647,	  '1556: randbit(20) == 817647');
	vrfy(randbit(20) == 476130,	  '1557: randbit(20) == 476130');
	vrfy(randbit(20) == 944201,	  '1558: randbit(20) == 944201');
	vrfy(randbit(20) == 822573,	  '1559: randbit(20) == 822573');
	tmp = srand(0);
	print				  '1560: tmp = srand(0)';
	vrfy(randbit(-20) == 20,	  '1561: randbit(-20) == 20');
	vrfy(randbit(20) == 476130,	  '1562: randbit(20) == 476130');
	vrfy(randbit(-20) == 20,	  '1563: randbit(-20) == 20');
	vrfy(randbit(20) == 822573,	  '1564: randbit(20) == 822573');

	/* test randbit without and arg */
	tmp = srand(0);
	print				  '1565: tmp = srand(0)';
	vrfy(randbit() == 1,		  '1566: randbit() == 1');
	vrfy(randbit() == 1,		  '1567: randbit() == 1');
	vrfy(randbit() == 0,		  '1568: randbit() == 0');

	print '1569: Ending rand test';
}
print '025: parsed test_rand()';


/*
 * Config mode/base testing
 */
define test_mode()
{
	local tmp;

	print '1600: Beginning mode/base test';

	tmp = config("mode", "frac");
	print				'1601: tmp = config("mode", "frac")';
	tmp = config("mode", "frac");
	print				'1602: tmp = config("mode", "frac")';
	vrfy(base() == 1/3,		'1603: base() == 1/3');

	tmp = config("mode", "int");
	print				'1604: tmp = config("mode", "int")';
	vrfy(tmp == "frac",		'1605: tmp == "frac"');
	vrfy(base() == -10,		'1606: base() == -10');

	tmp = config("mode", "real");
	print				'1607: tmp = config("mode", "real")';
	vrfy(tmp == "int",		'1608: tmp == "int"');
	vrfy(base() == 10,		'1609: base() == 10');

	tmp = config("mode", "exp");
	print				'1610: tmp = config("mode", "exp")';
	vrfy(tmp == "real",		'1611: tmp == "real"');
	vrfy(base() == 1e20,		'1612: base() == 1e20');

	tmp = config("mode", "hex");
	print				'1613: tmp = config("mode", "hex")';
	vrfy(tmp == "exp",		'1614: tmp == "exp"');
	vrfy(base() == 16,		'1615: base() == 16');

	tmp = config("mode", "oct");
	print				'1616: tmp = config("mode", "oct")';
	vrfy(tmp == "hexadecimal",	'1617: tmp == "hexadecimal"');
	vrfy(base() == 8,		'1618: base() == 8');

	tmp = config("mode", "bin");
	print				'1619: tmp = config("mode", "bin")';
	vrfy(tmp == "octal",		'1620: tmp == "octal"');
	vrfy(base() == 2,	 	'1621: base() == 2');

	tmp = config("mode", "real");
	print			 	'1622: tmp = config("mode", "real")';
	vrfy(tmp == "binary",	  	'1623: tmp == "binary"');

	tmp = base(1/3);
	print			  	'1624: tmp = base(1/3)';
	vrfy(config("mode") == "frac",  '1625: config("mode") == "frac"');

	tmp = base(-10);
	print			  	'1626: tmp = base(-10)';
	vrfy(config("mode") == "int",   '1627: config("mode") == "int"');

	tmp = base(10);
	print			  	'1628: tmp = base(10)';
	vrfy(config("mode") == "real",  '1629: config("mode") == "real"');

	tmp = base(1e20);
	print			  	'1630: tmp = base(1e20)';
	vrfy(config("mode") == "exp",   '1631: config("mode") == "exp"');

	tmp = base(16);
	print			  	'1632: tmp = base(16)';
	vrfy(config("mode") == "hexadecimal", \
		'1633: config("mode") == "hexadecimal"');

	tmp = base(8);
	print			 	'1634: tmp = base(8)';
	vrfy(config("mode") == "octal", '1635: config("mode") == "octal"');

	tmp = base(2);
	print			  	'1636: tmp = base(2)';
	vrfy(config("mode") == "binary",'1637: config("mode") == "binary"');

	tmp = base(8);
	print			  	'1638: tmp = base(8)';
	vrfy(str(0x80000000) == "020000000000", \
		'1639: str(0x8000000) == \"020000000000\"');
	vrfy(str(0xffffffff) == "037777777777", \
		'1640: str(0xffffffff) == \"037777777777\"');
	vrfy(str(3e9) == "026264057000", \
		'1641: str(3e9) == \"026264057000\"');

	tmp = base(16);
	print			  	'1642: tmp = base(16)';
	vrfy(str(0x80000000) == "0x80000000", \
		'1643: str(0x8000000) == \"0x80000000\"');
	vrfy(str(0xffffffff) == "0xffffffff", \
		'1644: str(0xffffffff) == \"0xffffffff\"');
	vrfy(str(3e9) == "0xb2d05e00", \
		'1645: str(3e9) == \"0xb2d05e00\"');

	tmp = base(10);
	print			  	'1646: tmp = base(10)';
	vrfy(config("mode") == "real", \
		'1647: config("mode") == "real"');

	vrfy(str(0x80000000) == "2147483648", \
		'1648: str(0x80000000) == \"2147483648\"');
	vrfy(str(0xffffffff) == "4294967295", \
		'1649: str(0xffffffff) == \"4294967295\"');
	vrfy(str(3e9) == "3000000000", \
		'1650: str(3e9) == \"3000000000\"');

	print '1651: Ending mode/base test';
}
print '026: parsed test_mode()';


/*
 * The 1700's contain tests for reading scripts.  These tests are
 * done inline near the bottom.
 */


/*
 * Test objects
 */
read -once "surd";
print '027: read -once surd';
/**/
define test_obj()
{
	static obj surd a;
	static obj surd b;

	print '1800: Beginning object test';

	surd_type = -1;
	vrfy(surd_type == -1,		'1801: surd_type == -1');
	a = surd(2,3);
	print				'1802: a = surd(2,3)';
	vrfy(a == surd(2,3),		'1803: a == surd(2,3)');
	vrfy(surd_value(a) == 2+3i,	'1804: surd_value(a) == 2+3i');
	vrfy(conj(a) == surd(2,-3),	'1805: conj(a) == surd(2,-3)');
	vrfy(norm(a) == 13,		'1806: norm(a) == 13');
	vrfy(a+1 == surd(3,3),		'1807: a+1 == surd(3,3)');
	b = surd(3,4);
	print				'1808: b = surd(3,4)';
	vrfy(a+b == surd(5,7),		'1809: a+b == surd(5,7)');
	vrfy(a-b == surd(-1,-1),	'1810: a-b == surd(-1,-1)');
	vrfy(++a == surd(3,3),		'1811: ++a == surd(3,3)');
	vrfy(--a == surd(2,3),		'1812: --a == surd(2,3)');
	vrfy(-a == surd(-2,-3),		'1813: -a == surd(-2,-3)');
	vrfy(a*2 == surd(4,6),		'1814: a*2 == surd(4,6)');
	vrfy(a*b == surd(-6,17),	'1815: a*b == surd(-6,17)');
	vrfy(a^2 == surd(-5,12),	'1816: a^2 == surd(-5,12)');
	vrfy(scale(a,2) == surd(8,12),	'1817: scale(a,2) == surd(8,12)');
	vrfy(a<<3 == surd(16,24),	'1818: a<<3 == surd(16,24)');
	vrfy(a/2 == surd(1,1.5),	'1819: a/2 == surd(1,1.5)');
	vrfy(a/b == surd(0.72,0.04),	'1820: a/b == surd(0.72,0.04)');
	vrfy(1/b == surd(0.12,-0.16),	'1821: 1/b == surd(0.12,-0.16)');
	vrfy(inverse(b) == 1/b,		'1822: inverse(b) == 1/b');
	vrfy(a != b,			'1823: a != b');
	surd_type = 2;
	print				'1824: surd_type = 2';
	vrfy(surd_type == 2,		'1825: surd_type == 2');
	vrfy(sgn(a) == 1,		'1826: sgn(a) == 1');
	vrfy(a < b,			'1827: a < b');
	vrfy(a <= a,			'1828: a < a');
	vrfy(isobj(a) == 1,		'1829: isobj(a) == 1');

	print '1830: Ending object test';
}
print '028: parsed test_obj()';


/*
 * Prime builtin function testing
 */
define test_prime()
{
	print '1900: Beginning prime builtins test';

	vrfy(isprime(-3) == 1,		'1901: isprime(-3) == 1');
	vrfy(isprime(-1) == 0,		'1902: isprime(-1) == 0');
	vrfy(isprime(0) == 0,		'1903: isprime(0) == 0');
	vrfy(isprime(1) == 0,		'1904: isprime(1) == 0');
	vrfy(isprime(2) == 1,		'1905: isprime(2) == 1');
	vrfy(isprime(3) == 1,		'1906: isprime(3) == 1');
	vrfy(isprime(4) == 0,		'1907: isprime(4) == 0');
	vrfy(isprime(5) == 1,		'1908: isprime(5) == 1');
	vrfy(isprime(17) == 1,		'1909: isprime(17) == 1');
	vrfy(isprime(100) == 0,		'1910: isprime(100) == 0');
	vrfy(isprime(21701,-1) == 1,	'1911: isprime(21701,-1) == 1');
	vrfy(isprime(65521,-1) == 1,	'1912: isprime(65521,-1) == 1');
	vrfy(isprime(65535,-1) == 0,	'1913: isprime(65535,-1) == 0');
	vrfy(isprime(65536,-1) == 0,	'1914: isprime(65536,-1) == 0');
	vrfy(isprime(1234577) == 1,	'1915: isprime(1234577) == 1');
	vrfy(isprime(1234579) == 0,	'1916: isprime(1234579) == 0');
	vrfy(isprime(2^31-9) == 0,	'1917: isprime(2^31-9) == 0');
	vrfy(isprime(2^31-1) == 1,	'1918: isprime(2^31-1) == 1');
	vrfy(isprime(2^31+9) == 0,	'1919: isprime(2^31+11) == 0');
	vrfy(isprime(2^31+11) == 1,	'1920: isprime(2^31+11) == 1');
	vrfy(isprime(3e9) == 0,		'1921: isprime(3e9) == 0');
	vrfy(isprime(3e9+19) == 1,	'1922: isprime(3e9+19) == 1');
	vrfy(isprime(2^32-7) == 0,	'1923: isprime(2^32-7) == 0');
	vrfy(isprime(2^32-5) == 1,	'1924: isprime(2^32-5) == 1');
	vrfy(isprime(2^32,-1) == 0,	'1925: isprime(2^32,-1) == 0');
	vrfy(isprime(2^32+1,-1) == -1,	'1926: isprime(2^32+1,-1) == -1');
	vrfy(isprime(3^99,2) == 2,	'1927: isprime(3^99,2) == 2');
	vrfy(isprime(4^99,2) == 0,	'1928: isprime(3^99,2) == 0');
	vrfy(nextprime(-3) == 5,	'1929: nextprime(-3) == 5');
	vrfy(nextprime(0) == 2,		'1930: nextprime(0) == 2');
	vrfy(nextprime(1) == 2,		'1931: nextprime(1) == 2');
	vrfy(nextprime(2) == 3,		'1932: nextprime(2) == 3');
	vrfy(nextprime(3) == 5,		'1933: nextprime(3) == 5');
	vrfy(nextprime(4) == 5,		'1934: nextprime(4) == 5');
	vrfy(nextprime(5) == 7,		'1935: nextprime(5) == 7');
	vrfy(nextprime(17) == 19,	'1936: nextprime(17) == 19');
	vrfy(nextprime(100) == 101,	'1937: nextprime(100) == 101');
	vrfy(nextprime(21701,-1) == 21713,
					'1938: nextprime(21701,-1) == 21713');
	vrfy(nextprime(65519) == 65521,
					'1939: nextprime(65519) == 65521');
	vrfy(nextprime(65520) == 65521,
					'1940: nextprime(65520) == 65521');
	vrfy(nextprime(65521,-1) == 65537,
					'1941: nextprime(65521,-1) == 65537');
	vrfy(nextprime(65531) == 65537,
					'1942: nextprime(65531) == 65537');
	vrfy(nextprime(65535,-1) == 65537,
					'1943: nextprime(65535,-1) == 65537');
	vrfy(nextprime(65536) == 65537,
					'1944: nextprime(65536) == 65537');
	vrfy(nextprime(1234576,2)==1234577,
				        '1945: nextprime(1234576,2)==1234577');
	vrfy(nextprime(2^31-9) == 2^31-1,
					'1946: nextprime(2^31-9) == 2^31-1');
	vrfy(nextprime(2^31-1) == 2^31+11,
					'1947: nextprime(2^31-1) == 2^31+11');
	vrfy(nextprime(3e9) == 3e9+19,'1948: nextprime(3e9) == 3e9+19');
	vrfy(nextprime(2^32-7) == 2^32-5,
					'1949: nextprime(2^32-7) == 2^32-5');
	vrfy(nextprime(2^32,-1) == -1,  '1950: nextprime(2^32,-1) == -1');
	vrfy(nextprime(2^32+5,-1) == -1,'1951: nextprime(2^32+5,-1) == -1');
	vrfy(nextprime(3^99,-1) == -1,  '1952: nextprime(3^99,-1) == -1');
	vrfy(nextprime(3^99,2) == 2,    '1953: nextprime(3^99,2) == 2');
	vrfy(prevprime(-3,-1) == 2,	'1954: prevprime(-3,-1) == 2');
	vrfy(prevprime(0,-1) == 0,	'1955: prevprime(0,-1) == 0');
	vrfy(prevprime(1,-1) == 0,	'1956: prevprime(1,-1) == 0');
	vrfy(prevprime(2,-2) == 0,	'1957: prevprime(2,-2) == 0');
	vrfy(prevprime(5) == 3,		'1958: prevprime(5) == 3');
	vrfy(prevprime(4) == 3,		'1959: prevprime(4) == 3');
	vrfy(prevprime(7) == 5,		'1960: prevprime(7) == 5');
	vrfy(prevprime(19) == 17,	'1961: prevprime(19) == 17');
	vrfy(prevprime(100) == 97,	'1962: prevprime(100) == 97');
	vrfy(prevprime(21713,-1) == 21701,
					'1963: prevprime(21713,-1) == 21701');
	vrfy(prevprime(65520) == 65519,
					'1964: prevprime(65520) == 65519');
	vrfy(prevprime(65521) == 65519,
					'1965: prevprime(65521) == 65519');
	vrfy(prevprime(65522) == 65521,
					'1966: prevprime(65520) == 65521');
	vrfy(prevprime(65523) == 65521,
					'1967: prevprime(65523) == 65521');
	vrfy(prevprime(65531) == 65521,
					'1968: prevprime(65531) == 65521');
	vrfy(prevprime(65535) == 65521,
					'1969: prevprime(65535) == 65521');
	vrfy(prevprime(65536) == 65521,
					'1970: prevprime(65536) == 65521');
	vrfy(prevprime(65537) == 65521,
					'1971: prevprime(65537) == 65521');
	vrfy(prevprime(65539) == 65537,
					'1972: prevprime(65539) == 65537');
	vrfy(prevprime(1234578,2)==1234577,
				        '1973: prevprime(1234578,2)==1234577');
	vrfy(prevprime(2^31-1) == 2^31-19,
					'1974: prevprime(2^31-1) == 2^31-19');
	vrfy(prevprime(2^31+11) == 2^31-1,
					'1975: prevprime(2^31+11) == 2^31-1');
	vrfy(prevprime(3e9) == 3e9-71,'1976: prevprime(3e9) == 3e9-17');
	vrfy(prevprime(2^32-3) == 2^32-5,
					'1977: prevprime(2^32-3) == 2^32-5');
	vrfy(prevprime(2^32-1) == 2^32-5,
					'1978: prevprime(2^32-1) == 2^32-5');
	vrfy(prevprime(2^32,-1) == -1,  '1979: prevprime(2^32,-1) == -1');
	vrfy(prevprime(3^99,-1) == -1,  '1980: prevprime(3^99,-1) == -1');
	vrfy(prevprime(3^99,2) == 2,    '1981: prevprime(3^99,2) == 2');
	vrfy(pix(-1) == 0,		'1982: pix(-1) == 0');
	vrfy(pix(1) == 0,		'1983: pix(1) == 0');
	vrfy(pix(2) == 1,		'1984: pix(2) == 1');
	vrfy(pix(3) == 2,		'1985: pix(3) == 2');
	vrfy(pix(100) == 25,		'1986: pix(100) == 25');
	vrfy(pix(1000) == 168,		'1987: pix(1000) == 168');
	vrfy(pix(10000) == 1229,	'1988: pix(10000) == 1229');
	vrfy(pix(100000) == 9592,	'1989: pix(100000) == 9592');
	vrfy(pix(2^19+59) == 43393,	'1990: pix(2^19+59) == 43393');
	vrfy(pix(1000000) == 78498,	'1991: pix(1000000) == 78498');
	vrfy(pix(10000000) == 664579,	'1992: pix(10000000) == 664579');
	vrfy(pix(2^32-6) == 203280220,  '1993: pix(2^32-6) == 203280220');
	vrfy(pix(2^32-5) == 203280221,  '1994: pix(2^32-5) == 203280221');
	vrfy(pix(2^32-1) == 203280221,  '1995: pix(2^32-1) == 203280221');
	vrfy(pfact(40) == 7420738134810,'1996: pfact(40) == 7420738134810');
	vrfy(pfact(200)/pfact(198)==199,'1997: pfact(200)/pfact(198)==199');
	vrfy(nextprime(3e9)==nextcand(3e9),
					'1998: nextprime(3e9)==nextcand(3e9)');
	vrfy(prevprime(3e9)==prevcand(3e9),
					'1999: prevprime(3e9)==prevcand(3e9)');
	vrfy(nextcand(2^100,0)-2^100 == 3,
					'2000: nextcand(2^100,0)-2^100 == 3');
	vrfy(nextcand(2^100)-2^100 == 277,
					'2001: nextcand(2^100)-2^100 == 277');
	vrfy(2^100-prevcand(2^100,0) == 5,
					'2002: 2^100-prevcand(2^100,0) == 5');
	vrfy(2^100-prevcand(2^100) == 15,
					'2003: 2^100-prevcand(2^100) == 15');
	vrfy(nextcand(2^50,4,5)-2^50 == 55,
					'2004: nextcand(2^50,4,5)-2^50 == 55');
	vrfy(2^50-prevcand(2^50,4,5) == 27,
					'2005: 2^50-prevcand(2^50,4,5) == 27');
	vrfy(nextprime(2^32-6) == 2^32-5,
					'2006: nextprime(2^32-6) == 2^32-5');
	vrfy(nextprime(2^32-5) == 2^32+15,
					'2007: nextprime(2^32-5) == 2^32+15');
	vrfy(prevprime(2^32-1) == 2^32-5,
					'2008: prevprime(2^32-1) == 2^32-5');
	vrfy(prevcand(2^50,4,5,0,4) == 0,
				'2009: prevcand(2^50,4,5,0,4) == 0');
	vrfy(2^50-prevcand(2^50,4,5,1,4) == 27,
				'2010: 2^50-prevcand(2^50,4,5,1,4) == 27');
	vrfy(prevcand(2^50,4,5,2,4) == 2,
				'2011: prevcand(2^50,4,5,2,4) == 2');
	vrfy(2^50-prevcand(2^50,4,5,3,4) == 113,
				'2012: 2^50-prevcand(2^50,4,5,3,4) == 113');
	vrfy(2^50-prevcand(2^50,4,5,7,17) == 813,
				'2013: 2^50-prevcand(2^50,4,5,7,17) == 813');
	vrfy(nextcand(2^50,4,5,0,4) == 0,
				'2014: nextcand(2^50,4,5,0,4) == 0');
	vrfy(nextcand(2^50,4,5,1,4)-2^50 == 145,
				'2015: nextcand(2^50,4,5,1,4)-2^50 == 145');
	vrfy(nextcand(2^50,4,5,2,4) == 0,
				'2016: nextcand(2^50,4,5,2,4) == 0');
	vrfy(nextcand(2^50,4,5,3,4)-2^50 == 55,
				'2017: nextcand(2^50,4,5,3,4)-2^50 == 55');
	vrfy(nextcand(2^50,4,5,7,17)-2^50 == 853,
				'2018: nextcand(2^50,4,5,7,17)-2^50 == 853');
	vrfy(ptest(2^100+277) == 1,	'2019: ptest(2^100+277) == 1');
	vrfy(ptest(2^50-27,4,5) == 1,	'2020: ptest(2^50-27,4,5) == 1');
	vrfy(ptest(2^50+55,4,5) == 1,	'2021: ptest(2^50+55,4,5) == 1');
	vrfy(ptest(2^32+1,10) == 0,	'2022: ptest(2^32+1,10) == 0');
	vrfy(lfactor(1001,100) == 7,	'2023: lfactor(1001,100) == 7');
	vrfy(lfactor(1001,4) == 7,	'2024: lfactor(1001,4) == 7');
	vrfy(lfactor(1001,3) == 1,	'2025: lfactor(1001,3) == 1');
	vrfy(lfactor(127,10000) == 1,   '2026: lfactor(127,10000) == 1');
	vrfy(lfactor(2^19-1,10000) == 1,'2027: lfactor(2^19-1,10000) == 1');
	vrfy(lfactor(2^31-1,10000) == 1,'2028: lfactor(2^31-1,10000) == 1');
	vrfy(lfactor(2^32-5,10000) == 1,'2029: lfactor(2^32-5,10000) == 1');
	vrfy(lfactor(2^38+7,50000) == 1,'2030: lfactor(2^38+7,50000) == 1');
	vrfy(lfactor(1009^2,pix(1009)) == 1009,
				'2031: lfactor(1009^2,pix(1009)) == 1009');
	vrfy(lfactor(1009^2,pix(1009)-1) == 1,
				'2032: lfactor(1009^2,pix(1009)-1) == 1');
	vrfy(lfactor(65519*65521,7000) == 65519,
				'2033: lfactor(65519*65521,7000) == 65519');
	vrfy(lfactor(65521^2,pix(65521)) == 65521,
				'2034: lfactor(65521^2,pix(65521)) == 65521');
	vrfy(lfactor(65521^2,pix(65521)-1) == 1,
				'2035: lfactor(65521^2,pix(65521)-1) == 1');
	vrfy(lfactor(524309^6,100000) == 524309,
				'2036: lfactor(524309^6,100000) == 524309');

	print '2037: Ending prime builtins test';
}
print '029: parsed test_prime()';


/*
 * Test the Lucas primality test library
 */
read -once "lucas_chk";		/* obtain our needed Lucas library */
print '030: read lucas_chk';
/**/
define test_lucas()
{
	print '2100: Beginning lucas check test';

	vrfy(lucas_chk(100,1) == 1,	'2101: lucas_chk(100,1) == 1');

	print '2102: Ending lucas check test';
}
print '031: parsed test_lucas()';


/*
 * Test new operator functionality
 */
define test_newop()
{
	static mat A[3] = {1,2,3};
	static mat A2[3] = {1,2,3};
	local B;
	local v;
	local a;
	local b;

	print '2200: Beginning new operator functionality test';

	(v = 3) = 4;
	print 			'2201: (v = 3) = 4';
	vrfy(v == 4,		'2202: v == 4');
	(v += 3) *= 4;
	print 			'2203: (v += 3) *= 4';
	vrfy(v == 28,		'2204: v == 28');
	vrfy(A == A2,		'2205: A == A2');
	matfill(B = A, 4);
	print			'2206: matfill(B = A, 4)';
	vrfy(A == A2,		'2207: A == A2');
	vrfy(size(B) == 3,	'2208: size(B) == 3');
	vrfy(B[0] == 4,	'2209: B[0] == 4');
	vrfy(B[1] == 4,	'2210: B[1] == 4');
	vrfy(B[2] == 4,	'2211: B[2] == 4');
	a = 3;
	print			'2212: a = 3';
	++(b = a);
	print			'2213: ++(b = a)';
	vrfy(a == 3,		'2214: a == 3');
	vrfy(b == 4,		'2215: b == 4');
	++++a;
	print			'2216: ++++a';
	vrfy(a == 5,		'2217: a == 5');
	vrfy((++a)++ == 6,	'2218: (++a)++ == 6');
	vrfy(a == 7,		'2219: a == 7');
	(++a) *= b;
	print			'2220: (++a) *= b';
	vrfy(a == 32,		'2221: a == 32');
	vrfy(b == 4,		'2222: b == 4');
	vrfy(++(a*=b) == 129, '2223: ++(a*=b) == 129');
	vrfy(a == 129,	'2224: a == 129');
	vrfy(b == 4,		'2225: b == 4');
	vrfy((a = (--a / b++))-- == 32,
				'2226: (a = (--a / b++))-- == 32');
	vrfy(a == 31,		'2227: a == 31');
	vrfy(b == 5,		'2228: b == 5');
	vrfy((++++a / ----b) == 11,
				'2229: (++++a / ----b) == 11');
	vrfy(a == 33,		'2230: a == 33');
	vrfy(b == 3,		'2231: b == 3');
	vrfy((a/=(--a/++b))-- == 4,
				'2232: (a/=(--a/++b))-- == 4');
	vrfy(a == 3,		'2233: a == 3');
	vrfy(b == 4,		'2234: b == 4');
	v = a----;
	print			'2235: v = a----';
	vrfy(v == 3,		'2236: v == 3');
	vrfy(a == 1,		'2237: a == 1');
	a = ----v;
	print			'2238: a = ----v';
	vrfy(a == 1,		'2239: a == 1');
	vrfy(v == 1,		'2240: v == 1');
	v = a++++;
	print			'2241: v = a++++';
	vrfy(a == 3,		'2242: a == 3');
	vrfy(v == 1,		'2243: v == 1');
	a = ++++v;
	print			'2244: a = ++++v';
	vrfy(a == 3,		'2245: a == 3');
	vrfy(v == 3,		'2246: v == 3');
	a = ----v----;
	print			'2247: a = ----v----';
	vrfy(a == 1,		'2248: a == 1');
	vrfy(v == -1,		'2249: v == -1');
	v = ++++a++++;
	print			'2250: v = ++++a++++';
	vrfy(a == 5,		'2251: a == 5');
	vrfy(v == 3,		'2252: v == 3');
	a = ++++v----;
	print			'2253: a = ++++v----';
	vrfy(a == 5,		'2254: a == 5');
	vrfy(v == 3,		'2255: v == 3');
	v = --++a--++;
	print			'2256: v = --++a--++';
	vrfy(a == 5,		'2257: a == 5');
	vrfy(v == 5,		'2258: v == 5');
	a = -++v;
	print			'2259: a = -++v';
	vrfy(a == -6,		'2260: a == -6');
	vrfy(v == 6,		'2261: v == 6');

	print '2262: Ending new operator functionality test';
}
print '032: parsed test_newop()';


/*
 * Test object increment/decrement
 */
read -once "test2300";
print '033: read -once test2300';
/**/
define test_xx_incdec()
{
	local A, B;

	print '2300: Beginning object increment/decrement test';

	A = mkmat(1,2,3);
	print			'2301: A = mkmat(1,2,3)';
	vrfy(ckmat(A,1,2,3) == 1,
				'2302: ckmat(A,1,2,3) == 1');
	B = A++;
	print			'2303: B = A++';
	vrfy(ckmat(B,1,2,3) == 1,
				'2304: ckmat(B,1,2,3) == 1');
	vrfy(ckmat(A,2,3,4) == 1,
				'2305: ckmat(A,2,3,4) == 1');
	B = A--;
	print			'2306: B = A--';
	vrfy(ckmat(A,1,2,3) == 1,
				'2307: ckmat(A,1,2,3) == 1');
	vrfy(ckmat(B,2,3,4) == 1,
				'2308: ckmat(B,2,3,4) == 1');
	B = ++A;
	print			'2309: B = ++A';
	vrfy(ckmat(A,2,3,4) == 1,
				'2310: ckmat(A,2,3,4) == 1');
	vrfy(ckmat(B,2,3,4) == 1,
				'2311: ckmat(B,2,3,4) == 1');
	B = --A;
	print			'2312: B = --A';
	vrfy(ckmat(A,1,2,3) == 1,
				'2313: ckmat(A,1,2,3) == 1');
	vrfy(ckmat(B,1,2,3) == 1,
				'2314: ckmat(B,1,2,3) == 1');

	print '2315: Ending object increment/decrement test';
}
print '034: parsed test_xx_incdec()';


/*
 * testing rounding config modes
 */
define test_round()
{
	local mode;

	print '2400: Beginning config rounding mode test';

	/* appr mode 0 */
	mode = 0;
	print			'2401: mode = 0';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2402: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2403: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 5,
				'2404: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -6,
				'2405: appr(-5.7,1,mode) == -6');
	vrfy(appr(-5.44,-0.1,mode) == -5.4,
				'2406: appr(-5.44,-0.1,mode) == -5.4');
	vrfy(appr(5.44,-0.1,mode) == 5.5,
				'2407: appr(5.44,-0.1,mode) == 5.5');
	vrfy(appr(5.7,-1,mode) == 6,
				'2408: appr(5.7,-1,mode) == 6');
	vrfy(appr(-5.7,-1,mode) == -5,
				'2409: appr(-5.7,-1,mode) == -5');

	/* appr mode 1 */
	mode = 1;
	print			'2410: mode = 1';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2411: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2412: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 6,
				'2413: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -5,
				'2414: appr(-5.7,1,mode) == -5');
	vrfy(appr(-5.44,-0.1,mode) == -5.5,
				'2415: appr(-5.44,-0.1,mode) == -5.5');
	vrfy(appr(5.44,-0.1,mode) == 5.4,
				'2416: appr(5.44,-0.1,mode) == 5.4');
	vrfy(appr(5.7,-1,mode) == 5,
				'2417: appr(5.7,-1,mode) == 5');
	vrfy(appr(-5.7,-1,mode) == -6,
				'2418: appr(-5.7,-1,mode) == -6');

	/* appr mode 2 */
	mode = 2;
	print			'2419: mode = 2';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2420: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2421: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 5,
				'2422: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -5,
				'2423: appr(-5.7,1,mode) == -5');

	/* appr mode 3 */
	mode = 3;
	print			'2424: mode = 3';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2425: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2426: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 6,
				'2427: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -6,
				'2428: appr(-5.7,1,mode) == -6');

	/* appr mode 4 */
	mode = 4;
	print			'2429: mode = 4';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2430: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2431: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 5,
				'2432: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -6,
				'2433: appr(-5.7,1,mode) == -6');

	/* appr mode 5 */
	mode = 5;
	print			'2434: mode = 5';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2435: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2436: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 6,
				'2437: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -5,
				'2438: appr(-5.7,1,mode) == -5');

	/* appr mode 6 */
	mode = 6;
	print			'2439: mode = 6';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2440: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2441: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 5,
				'2442: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -5,
				'2443: appr(-5.7,1,mode) == -5');
	vrfy(appr(-5.44,-0.1,mode) == -5.5,
				'2444: appr(-5.44,-0.1,mode) == -5.5');
	vrfy(appr(5.44,-0.1,mode) == 5.5,
				'2445: appr(5.44,-0.1,mode) == 5.5');
	vrfy(appr(5.7,-1,mode) == 6,
				'2446: appr(5.7,-1,mode) == 6');
	vrfy(appr(-5.7,-1,mode) == -6,
				'2447: appr(-5.7,-1,mode) == -6');

	/* appr mode 7 */
	mode = 7;
	print			'2448: mode = 7';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2449: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2450: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 6,
				'2451: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -6,
				'2452: appr(-5.7,1,mode) == -6');
	vrfy(appr(-5.44,-0.1,mode) == -5.4,
				'2453: appr(-5.44,-0.1,mode) == -5.4');
	vrfy(appr(5.44,-0.1,mode) == 5.4,
				'2454: appr(5.44,-0.1,mode) == 5.4');
	vrfy(appr(5.7,-1,mode) == 5,
				'2455: appr(5.7,-1,mode) == 5');
	vrfy(appr(-5.7,-1,mode) == -5,
				'2456: appr(-5.7,-1,mode) == -5');

	/* appr mode 8 */
	mode = 8;
	print			'2457: mode = 8';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2458: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2459: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 6,
				'2460: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -6,
				'2461: appr(-5.7,1,mode) == -6');

	/* appr mode 9 */
	mode = 9;
	print			'2462: mode = 9';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2463: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2464: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 5,
				'2465: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -5,
				'2466: appr(-5.7,1,mode) == -5');

	/* appr mode 10 */
	mode = 10;
	print			'2467: mode = 10';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2468: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2469: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 6,
				'2470: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -5,
				'2471: appr(-5.7,1,mode) == -5');
	vrfy(appr(-5.44,-0.1,mode) == -5.4,
				'2472: appr(-5.44,-0.1,mode) == -5.4');
	vrfy(appr(5.44,-0.1,mode) == 5.5,
				'2473: appr(5.44,-0.1,mode) == 5.5');
	vrfy(appr(5.7,-1,mode) == 5,
				'2474: appr(5.7,-1,mode) == 5');
	vrfy(appr(-5.7,-1,mode) == -6,
				'2475: appr(-5.7,-1,mode) == -6');

	/* appr mode 11 */
	mode = 11;
	print			'2476: mode = 11';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2477: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2478: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 5,
				'2479: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -6,
				'2480: appr(-5.7,1,mode) == -6');
	vrfy(appr(-5.44,-0.1,mode) == -5.5,
				'2481: appr(-5.44,-0.1,mode) == -5.5');
	vrfy(appr(5.44,-0.1,mode) == 5.4,
				'2482: appr(5.44,-0.1,mode) == 5.4');
	vrfy(appr(5.7,-1,mode) == 6,
				'2483: appr(5.7,-1,mode) == 6');
	vrfy(appr(-5.7,-1,mode) == -5,
				'2484: appr(-5.7,-1,mode) == -5');

	/* appr mode 12 */
	mode = 12;
	print			'2485: mode = 12';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2486: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2487: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 6,
				'2488: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -6,
				'2489: appr(-5.7,1,mode) == -6');
	vrfy(appr(-5.44,-0.1,mode) == -5.5,
				'2490: appr(-5.44,-0.1,mode) == -5.5');
	vrfy(appr(5.44,-0.1,mode) == 5.5,
				'2491: appr(5.44,-0.1,mode) == 5.5');
	vrfy(appr(5.7,-1,mode) == 5,
				'2492: appr(5.7,-1,mode) == 5');
	vrfy(appr(-5.7,-1,mode) == -5,
				'2493: appr(-5.7,-1,mode) == -5');

	/* appr mode 13 */
	mode = 13;
	print			'2494: mode = 13';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2495: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2496: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 5,
				'2497: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -5,
				'2498: appr(-5.7,1,mode) == -5');
	vrfy(appr(-5.44,-0.1,mode) == -5.4,
				'2499: appr(-5.44,-0.1,mode) == -5.4');
	vrfy(appr(5.44,-0.1,mode) == 5.4,
				'2500: appr(5.44,-0.1,mode) == 5.4');
	vrfy(appr(5.7,-1,mode) == 6,
				'2501: appr(5.7,-1,mode) == 6');
	vrfy(appr(-5.7,-1,mode) == -6,
				'2502: appr(-5.7,-1,mode) == -6');

	/* appr mode 14 */
	mode = 14;
	print			'2503: mode = 14';
	vrfy(appr(-5.44,0.1,mode) == -5.5,
				'2504: appr(-5.44,0.1,mode) == -5.5');
	vrfy(appr(5.44,0.1,mode) == 5.4,
				'2505: appr(5.44,0.1,mode) == 5.4');
	vrfy(appr(5.7,1,mode) == 6,
				'2506: appr(5.7,1,mode) == 6');
	vrfy(appr(-5.7,1,mode) == -5,
				'2507: appr(-5.7,1,mode) == -5');
	vrfy(appr(-5.44,-0.1,mode) == -5.5,
				'2508: appr(-5.44,-0.1,mode) == -5.5');
	vrfy(appr(5.44,-0.1,mode) == 5.4,
				'2509: appr(5.44,-0.1,mode) == 5.4');
	vrfy(appr(5.7,-1,mode) == 6,
				'2510: appr(5.7,-1,mode) == 6');
	vrfy(appr(-5.7,-1,mode) == -5,
				'2511: appr(-5.7,-1,mode) == -5');

	/* appr mode 15 */
	mode = 15;
	print			'2512: mode = 15';
	vrfy(appr(-5.44,0.1,mode) == -5.4,
				'2513: appr(-5.44,0.1,mode) == -5.4');
	vrfy(appr(5.44,0.1,mode) == 5.5,
				'2514: appr(5.44,0.1,mode) == 5.5');
	vrfy(appr(5.7,1,mode) == 5,
				'2515: appr(5.7,1,mode) == 5');
	vrfy(appr(-5.7,1,mode) == -6,
				'2516: appr(-5.7,1,mode) == -6');
	vrfy(appr(-5.44,-0.1,mode) == -5.4,
				'2517: appr(-5.44,-0.1,mode) == -5.4');
	vrfy(appr(5.44,-0.1,mode) == 5.5,
				'2518: appr(5.44,-0.1,mode) == 5.5');
	vrfy(appr(5.7,-1,mode) == 5,
				'2519: appr(5.7,-1,mode) == 5');
	vrfy(appr(-5.7,-1,mode) == -6,
				'2520: appr(-5.7,-1,mode) == -6');

	print '2521: Ending config rounding mode test';
}
print '035: parsed test_round()';


/*
 * Test certain numeric functions extensively
 *
 * Test multiplication, sqrt(), exp(), ln(), power(), gcd(), complex
 * power, complex exp, complex log.
 */
read -once "test2600";
print '036: read -once test2600';
define test_2600()
{
	local tnum;	/* test number */
	local i;

	print '2600: Beginning extensive numeric function test';

	i = config("sqrt");
	print '2601: i = config("sqrt")';

	tnum = test2600(1, 2602);

	i = config("sqrt", i);
	print tnum++: ': i = config("sqrt", i)';

	print tnum: ': Ending extensive numeric function test';
}
print '037: parsed test_2600()';


/*
 * Test complex sqrt
 */
read -once "test2700";
print '038: read -once test2700';
define test_2700()
{
	local tnum;	/* test number */

	print '2700: Beginning complex sqrt test';

	tnum = test2700(1, 2701);

	print tnum: ': Ending complex sqrt test';
}
print '039: parsed test_2700()';


/*
 * Test matrix operations
 */
mat mat_C[2] = {1,2};
print '040: mat mat_C[2] = {1,2}';
mat_C[0] = mat_C;
print '041: C[0] = mat_C';
global mat_D;
print '042: global mat_D';
/**/
define test_matrix()
{
	static mat b[4,4];
	static mat binv[4,4] = {
	    0, 1, 0, 0, 2, -3/2, 2, -1/2, -3,
	    0.5, -1.0, 0.5, 1.0, 0.0, 0.0, 0.0
	};
	static mat c[] = { 1, 2+3i, -5+4i, 5i+6, -7i };
	static mat d[-1:1, -2:2, -3:3, -4:4];
	static mat A[2] = {1,2};
	static mat id0[2,2] = {1,0,0,1};
	static mat id1[0:2,-1:1] = {1,0,0,0,1,0,0,0,1};
	static mat noid0[2,2] = {1,2,0,1};
	static mat noid1[2,3] = {1,0,0,1,0,0};
	static mat noid2[4] = {1,0,0,1};
	static mat xp[3] = {2,3,4};
	static mat yp[3] = {3,4,5};
	static mat zp[3] = {-1,2,-1};
	static mat X[2,2] = {1,2,3,4};
	static mat Y[2,2] = {5,6,7,8};
	static mat Z[2,2] = {190,232,286,352};
	static mat x[] = {11,13,17,23,29};
	static mat y0[] = {1,3,7,3,9};
	static mat y1[] = {-9,-7,-3,-7,-1};
	static mat y2[] = {-9,-7,-3,3,9};
	static mat y3[] = {1,3,7,-7,-1};
	static mat y4[] = {1,3,-3,3,-1};
	local B;
	local mat e[5,5];
	local mat M[2];
	local mat zero3[3];

	print '2800: Beginning test_matrix';

	b[0,0] = 0;
	vrfy(b[0,0] == 0,		'2801: b[0,0] == 0');
	b[0,1] = 0;
	vrfy(b[0,1] == 0,		'2802: b[0,1] == 0');
	b[0,2] = 0;
	vrfy(b[0,2] == 0,		'2803: b[0,2] == 0');
	b[0,3] = 1;
	vrfy(b[0,3] == 1,		'2804: b[0,3] == 1');
	b[1,0] = 1;
	vrfy(b[1,0] == 1,		'2805: b[1,0] == 1');
	b[1,1] = 0;
	vrfy(b[1,1] == 0,		'2806: b[1,1] == 0');
	b[1,2] = 0;
	vrfy(b[1,2] == 0,		'2807: b[1,2] == 0');
	b[1,3] = 0;
	vrfy(b[1,3] == 0,		'2808: b[1,3] == 0');
	b[2,0] = 1;
	vrfy(b[2,0] == 1,		'2809: b[2,0] == 1');
	b[2,1] = 1;
	vrfy(b[2,1] == 1,		'2810: b[2,1] == 1');
	b[2,2] = 1;
	vrfy(b[2,2] == 1,		'2811: b[2,2] == 1');
	b[2,3] = 1;
	vrfy(b[2,3] == 1,		'2812: b[2,3] == 1');
	b[3,0] = 1;
	vrfy(b[3,0] == 1,		'2813: b[3,0] == 1');
	b[3,1] = 2;
	vrfy(b[3,1] == 2,		'2814: b[3,1] == 2');
	b[3,2] = 4;
	vrfy(b[3,2] == 4,		'2815: b[3,2] == 4');
	b[3,3] = 8;
	vrfy(b[3,3] == 8,		'2816: b[3,3] == 8');
	vrfy(det(b) == -2,		'2817: det(b) == -2');
	vrfy(binv[0,0] == 0,		'2818: binv[0,0] == 0');
	vrfy(binv[0,1] == 1,		'2819: binv[0,1] == 1');
	vrfy(binv[0,2] == 0,		'2820: binv[0,2] == 0');
	vrfy(binv[0,3] == 0,		'2821: binv[0,3] == 0');
	vrfy(binv[1,0] == 2,		'2822: binv[1,0] == 2');
	vrfy(binv[1,1] == -3/2,		'2823: binv[1,1] == -3/2');
	vrfy(binv[1,2] == 2,		'2824: binv[1,2] == 2');
	vrfy(binv[1,3] == -1/2,		'2825: binv[1,3] == -1/2');
	vrfy(binv[2,0] == -3,		'2826: binv[2,0] == -3');
	vrfy(binv[2,1] == 1/2,		'2827: binv[2,1] == 1/2');
	vrfy(binv[2,2] == -1,		'2828: binv[2,2] == -1');
	vrfy(binv[2,3] == 1/2,		'2829: binv[2,3] == 1/2');
	vrfy(binv[3,0] == 1,		'2830: binv[3,0] == 1');
	vrfy(binv[3,1] == 0,		'2831: binv[3,1] == 0');
	vrfy(binv[3,2] == 0,		'2832: binv[3,2] == 0');
	vrfy(binv[3,3] == 0,		'2833: binv[3,3] == 0');
	vrfy(inverse(b) == binv,	'2834: inverse(b) == binv');
	vrfy(avg(b) == b,		'2835: avg(b) == b');
	vrfy(avg(binv) == binv,		'2836: avg(binv) == binv');
	vrfy((b+binv)/2 == avg(b,binv), '2837: (b+binv)/2 == avg(b,binv)');
	vrfy(ismat(b) == 1,		'2838: ismat(b) == 1');
	vrfy(matsum(b) == 21,		'2839: matsum(b) == 21');
	vrfy(matsum(binv) == 1,		'2840: matsum(binv) == 1');
	vrfy(c[0] == 1,			'2841: c[0] == 1');
	vrfy(c[1] == 2+3i,		'2842: c[1] == 2+3i');
	vrfy(c[2] == -5+4i,		'2843: c[2] == -5+4i');
	vrfy(c[3] == 6+5i,		'2844: c[3] == 6+5i');
	vrfy(c[4] == -7i,		'2845: c[4] == -7i');
	vrfy(matsum(c) == 4+5i,		'2846: matsum(c) == 4+5i');
	vrfy(matdim(b) == 2,		'2847: matdim(b) == 2');
	vrfy(matdim(c) == 1,		'2848: matdim(c) == 1');
	vrfy(matdim(d) == 4,		'2849: matdim(c) == 4');
	vrfy(matmax(c,1) == 4,		'2850: matmax(c,1) == 4');
	vrfy(matmin(c,1) == 0,		'2851: matmin(c,1) == 0');
	vrfy(matmin(d,1) == -1,		'2852: matmin(d,1) == -1');
	vrfy(matmin(d,3) == -3,		'2853: matmin(d,3) == -3');
	vrfy(matmax(d,1) == 1,		'2854: matmin(d,1) == 1');
	vrfy(matmax(d,3) == 3,		'2855: matmin(d,3) == 3');
	vrfy(size(binv) == 16,		'2856: size(binv) == 16');
	vrfy(size(c) == 5,		'2857: size(c) == 5');
	vrfy(size(d) == 945,		'2858: size(d) == 945');
	vrfy(size(e) == 25,		'2859: size(e) == 25');
	matfill(d,1);
	print				'2860: matfill(d,1)';
	vrfy(matsum(d) == 945,		'2861: matsum(d) == 945');
	matfill(e,1,0);
	print				'2862: matfill(e,1,0)';
	vrfy(matsum(d) == 945,		'2863: matsum(d) == 945');
	vrfy(matsum(e) == 20,	   	'2864: matsum(e) == 20');
	vrfy(search(binv,1) == 1,	'2865: search(binv,1) == 1');
	vrfy(search(binv,2) == 4,	'2866: search(binv,2) == 4');
	vrfy(search(binv,2,4) == 4,	'2867: search(binv,2,4) == 4');
	vrfy(search(binv,2,5) == 6,	'2868: search(binv,2,5) == 6');
	vrfy(rsearch(binv,2) == 6,	'2869: rsearch(binv,2) == 6');
	vrfy(rsearch(binv,2,6) == 6,	'2870: rsearch(binv,2,6) == 6');
	vrfy(rsearch(binv,2,5) == 4,	'2871: rsearch(binv,2,5) == 4');
	vrfy(A[0] == 1,			'2872: A[0] == 1');
	vrfy(A[1] == 2,			'2873: A[1] == 2');
	A[0] = A;
	print				'2874: A[0] = A';
	B = A[0];
	print				'2875: B = A[0]';
	vrfy(B[0] == 1,			'2876: B[0] == 1');
	vrfy(B[1] == 2,			'2877: B[1] == 2');
	mat_D = mat_C[0];
	print				'2878: mat_D = mat_C[0]';
	vrfy(mat_D[0] == 1,		'2879: mat_D[0] == 1');
	vrfy(mat_D[1] == 2,		'2880: mat_D[1] == 2');
	vrfy(quomod(15.6,5.2,M[0],M[1]) == 0,
				      '2881: quomod(15.6,5.2,M[0],M[1]) == 0');
	vrfy(M[0] == 3,			'2882: M[0] == 3');
	vrfy(M[1] == 0,			'2883: M[1] == 0');
	vrfy(isident(id0) == 1,		'2884: isident(id0) == 1');
	vrfy(isident(id1) == 1,		'2885: isident(id1) == 1');
	vrfy(isident(noid0) == 0,	'2886: isident(noid0) == 0');
	vrfy(isident(noid1) == 0,	'2887: isident(noid1) == 0');
	vrfy(isident(noid2) == 0,	'2888: isident(noid2) == 0');
	vrfy(xp[0] == 2,		'2889: xp[0] == 2');
	vrfy(xp[1] == 3,		'2890: xp[1] == 3');
	vrfy(xp[2] == 4,		'2891: xp[2] == 4');
	vrfy(yp[0] == 3,		'2892: yp[0] == 3');
	vrfy(yp[1] == 4,		'2893: yp[1] == 4');
	vrfy(yp[2] == 5,		'2894: yp[2] == 5');
	vrfy(zp[0] == -1,		'2895: zp[0] == -1');
	vrfy(zp[1] == 2,		'2896: zp[1] == 2');
	vrfy(zp[2] == -1,		'2897: zp[2] == -1');
	vrfy(cp(xp,yp) == zp,		'2898: cp(xp,yp) == zp');
	vrfy(cp(yp,xp) == -zp,		'2899: cp(yp,xp) == -zp');
	matfill(zero3,0);
	print 				'2900: matfill(zero3,0)';
	vrfy(cp(xp,xp) == zero3,	'2901: cp(xp,xp) == zero3');
	vrfy(dp(xp,yp) == 38,		'2902: dp(xp,yp) == 38');
	vrfy(dp(yp,xp) == 38,		'2903: dp(yp,xp) == 38');
	vrfy(dp(zp,dp(xp,yp)*zp) == 228,'2904: dp(zp,dp(xp,yp)*zp) == 228');
	vrfy(ssq(X, Y, X + Y) == Z,	'2905: ssq(X, Y, X + Y) == Z');
	vrfy(mod(x,10,0) == y0,		'2906: mod(x,10,0) == y0');
	vrfy(mod(x,10,1) == y1,		'2907: mod(x,10,1) == y1');
	vrfy(mod(x,10,2) == y0,		'2908: mod(x,10,2) == y0');
	vrfy(mod(x,10,3) == y1,		'2909: mod(x,10,3) == y1');
	vrfy(mod(x,10,4) == y0,		'2910: mod(x,10,4) == y0');
	vrfy(mod(x,10,5) == y1,		'2911: mod(x,10,5) == y1');
	vrfy(mod(x,10,6) == y0,		'2912: mod(x,10,6) == y0');
	vrfy(mod(x,10,7) == y1,		'2913: mod(x,10,7) == y1');
	vrfy(mod(x,10,8) == y2,		'2914: mod(x,10,8) == y2');
	vrfy(mod(x,10,9) == y3,		'2915: mod(x,10,9) == y3');
	vrfy(mod(x,10,10) == y2,	'2916: mod(x,10,10) == y2');
	vrfy(mod(x,10,11) == y3,	'2917: mod(x,10,11) == y3');
	vrfy(mod(x,10,12) == y2,	'2918: mod(x,10,12) == y2');
	vrfy(mod(x,10,13) == y3,	'2919: mod(x,10,13) == y3');
	vrfy(mod(x,10,14) == y2,	'2920: mod(x,10,14) == y2');
	vrfy(mod(x,10,15) == y3,	'2921: mod(x,10,15) == y3');
	vrfy(mod(x,10,16) == y4,	'2922: mod(x,10,16) == y4');
	vrfy(mod(x,10,16) == y4,	'2923: mod(x,10,16) == y4');
	vrfy(mod(x,10,18) == y4,	'2924: mod(x,10,18) == y4');
	vrfy(mod(x,10,19) == y4,	'2925: mod(x,10,18) == y4');
	vrfy(mod(x,10,20) == y4,	'2926: mod(x,10,20) == y4');
	vrfy(mod(x,10,21) == y4,	'2927: mod(x,10,21) == y4');
	vrfy(mod(x,10,22) == y4,	'2928: mod(x,10,22) == y4');
	vrfy(mod(x,10,23) == y4,	'2929: mod(x,10,23) == y4');
	vrfy(mod(x,10,24) == y4,	'2930: mod(x,10,24) == y4');
	vrfy(mod(x,10,25) == y4,	'2931: mod(x,10,25) == y4');
	vrfy(mod(x,10,26) == y4,	'2932: mod(x,10,26) == y4');
	vrfy(mod(x,10,27) == y4,	'2933: mod(x,10,27) == y4');
	vrfy(mod(x,10,28) == y4,	'2934: mod(x,10,28) == y4');
	vrfy(mod(x,10,29) == y4,	'2935: mod(x,10,29) == y4');
	vrfy(mod(x,10,30) == y4,	'2936: mod(x,10,30) == y4');
	vrfy(mod(x,10,31) == y4,	'2937: mod(x,10,31) == y4');

	print '2938: Ending mat_functions';
}
print '043: parsed test_matrix()';


/*
 * Test string constants and comparisons
 */
define test_strings()
{
	local x, y, z;

	print '3000: Beginning test_strings';

	x = 'string';
	print 				"3001: x = 'string'";
	y = "string";
	print 				'3002: y = "string"';
	z = x;
	print 				'3003: z = x';
	vrfy(z == "string", 		'3004: z == "string"');
	vrfy(z != "foo",		'3005: z != "foo"');
	vrfy(z != 3,			'3006: z != 3');
	vrfy('' == "",		'3007: \'\' == ""');
	vrfy("a" == "a",		'3008: "a" == "a"');
	vrfy("c" != "d",		'3009: "c" != "d"');
	vrfy("" != "a",		'3010: "" != "a"');
	vrfy("rs" < "rt",		'3011: "rs" < "rt"');
	vrfy("rs" < "ss",		'3012: "rs < "ss"');
	vrfy("rs" <= "rs",		'3013: "rs" <= "rs"');
	vrfy("rs" <= "tu",		'3014: "rs" <= "tu"');
	vrfy("rs" > "cd",		'3015: "rs" > "cd"');
	vrfy("rs" >= "rs",		'3016: "rs" >= "rs"');
	vrfy("rs" >= "cd",		'3017: "rs" >= "cd"');
	vrfy("abc" > "ab",		'3018: "abc" > "ab"');

	print '3019: Ending test_strings';
}
print '044: parsed test_strings()';


/*
 * test_matobj - test determinants of a matrix containing objects
 */
read -once "test3100";
print '045: read -once test3100';
/**/
define test_matobj()
{
	local mat A[3,3] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
	local mat B[2,2];

	print '3100: Beginning test_matobj';

	vrfy(det(A) == -78,		'3101: det(A) == -78');
	vrfy(det(A^2) == 6084,		'3102: det(A^2) == 6084');
	vrfy(det(A^3) == -474552,	'3103: det(A^3) == -474552');
	vrfy(det(A^-1) == -1/78,	'3104: det(A^-1) == -1/78');
	md = 0;
	print 				'3105: md = 0';
	B[0,0] = res(2);
	print				'3106: B[0,0] = res(2)';
	B[0,1] = res(3);
	print				'3107: B[0,1] = res(2)';
	B[1,0] = res(5);
	print				'3108: B[1,0] = res(2)';
	B[1,1] = res(7);
	print				'3109: B[1,1] = res(2)';
	print				'3110: md = 0';
	md = 0;
	vrfy(det(B) == res(-1),		'3111: det(B) == res(-1)');
	md = 1;
	print				'3112: md = 1';
	vrfy(det(B) == 0,		'3113: det(B) == 0');
	md = 2;
	print				'3114: md = 2';
	vrfy(det(B) == res(1),		'3115: det(B) == res(1)');
	md = 3;
	print				'3116: md = 3';
	vrfy(det(B) == res(2),		'3117: det(B) == res(2)');
	md = 4;
	print				'3118: md = 4';
	vrfy(det(B) == res(3),		'3119: det(B) == res(3)');
	md = 5;
	print				'3120: md = 5';
	vrfy(det(B) == res(4),		'3121: det(B) == res(4)');
	md = 6;
	print				'3122: md = 6';
	vrfy(det(B) == res(5),		'3123: det(B) == res(5)');
	md = 7;
	print				'3124: md = 7';
	vrfy(det(B) == res(6),		'3125: det(B) == res(6)');
	md = 8;
	print				'3126: md = 8';
	vrfy(det(B) == res(7),		'3127: det(B) == res(7)');
	md = 9;
	print				'3128: md = 9';
	vrfy(det(B) == res(8),		'3129: det(B) == res(8)');
	md = 10;
	print				'3130: md = 10';
	vrfy(det(B) == res(9),		'3131: det(B) == res(9)');
	md = 11;
	print				'3132: md = 11';
	vrfy(det(B) == res(10),		'3133: det(B) == res(10)');
	md = 12;
	print				'3134: md = 12';
	vrfy(det(B) == res(11),		'3135: det(B) == res(11)');
	md = 13;
	print				'3136: md = 13';
	vrfy(det(B) == res(12),		'3137: det(B) == res(12)');
	md = 14;
	print				'3138: md = 14';
	vrfy(det(B) == res(13),		'3139: det(B) == res(13)');
	md = 15;
	print				'3140: md = 15';
	vrfy(det(B) == res(14),		'3141: det(B) == res(14)');

	print '3142: Ending test_matobj';
}
print '046: parsed test_matobj()';


/*
 * test_poly - test the polynomial function
 */
define test_poly()
{
	print '3200: Beginning test_matobj';

	vrfy(poly(2,3,5,2) == 19, '3201: vrfy poly(2,3,5,2) == 19');
	vrfy(poly(list(5,3,2),2) == 19,\
		 '3202: vrfy poly(list(5,3,2),2) == 19');
	vrfy(poly(list(5,3,2)) == 5, '3203: vrfy poly(list(5,3,2)) == 5');
	vrfy(poly(2) == 2, '3204: vrfy poly(2) == 2');
	vrfy(poly(list(5,3,2),2,3) == 19,\
		 '3205: vrfy poly(list(5,3,2),2,3) == 19');
	vrfy(poly(list()) == 0, '3206: vrfy poly(list()) == 0');
	vrfy(poly(list(),2,3) == 0, '3207: vrfy poly(list(),2,3) == 0');
	vrfy(poly(list(list(5,3,2)),7,2) == 19,\
		'3208: vrfy poly(list(list(5,3,2)),7,2) == 19');
	vrfy(poly(list(list(1,2,3),list(4,5),6),7) == 323,\
		'3209: vrfy poly(list(list(1,2,3),list(4,5),6),7) == 323');
	vrfy(poly(list(list(1,2,3),list(4,5),6),7,8) == 811,\
		'3210: vrfy poly(list(list(1,2,3),list(4,5),6),7,8) == 811');
	vrfy(poly(list(list(1,2,3),list(4,5),6),7,8,9) == 811,\
		'3211: vrfy poly(list(list(1,2,3),list(4,5),6),7,8,9)==811');
	vrfy(poly(list(5,3,2), list()) == 5,\
		'3212: vrfy poly(list(5,3,2), list() == 5');
	vrfy(poly(list(5,3,2), list(2)) == 19,\
		'3213: vrfy poly(list(5,3,2), list(2)) == 19');
	vrfy(poly(list(5,3,2), list(2,3)) == 19,\
		'3214: vrfy poly(list(5,3,2), list(2,3)) == 19');
	vrfy(poly(list(list(list(0,0,0,0,0,1))),2,3,4) == 4^5,\
		'3215: vrfy poly(list(list(list(0,0,0,0,0,1))),2,3,4)==4^5');
	vrfy(poly(list(list(list(0,0,0,0,0,1))),2,list(3,4)) == 4^5,\
		'3216: vrfy poly(list(list(list(0,0,0,0,0,1))),2,list(3,4))==4^5');

	print '3217: Ending test_poly';
}
print '047: parsed test_poly()';


/*
 * test_det - more determinent testing
 */
read -once "test3300";
print '048: read -once test3300';
/**/
define test_det()
{
	local tnum;	/* test number */
	local i;

	print '3300: Beginning test_det';

	tnum = test3300(1, 3301);

	print tnum: ': Ending test_det';
}
print '049: parsed test_det()';


/*
 * test_trig - trig function testing
 */
read -once "test3400";
print '050: read -once test3400';
/**/
define test_trig()
{
	local tnum;	/* test number */
	local i;

	print '3400: Beginning test_trig';

	tnum = test3400(1, 3401);

	print tnum: ': Ending test_trig';
}
print '051: parsed test_trig()';


/*
 * test_frem - tests of the functions frem, fcnt, gcdrem
 */
read -once "test3500";
print '052: read -once test3500';
/**/
define test_frem()
{
	local tnum;	/* test number */

	print '3500: Beginning test_frem';

	tnum = test3500(1, 3501, 200, 61);

	print tnum: ': Ending test_frem';
}
print '053: parsed test_frem()';


/*
 * test_error - test the error() builtin
 */
define test_error()
{
	local strx, e99, list1;

	print '3600: Beginning test_error';

	strx = "x";
	print				'3601: strx = "x"';
	e99 = error(99);
	print				'3602: e99 = error(99)';
	vrfy(1/0 == error(10001),	'3603: 1/0 == error(10001)');
	vrfy(0/0 == error(10002),	'3604: 0/0 == error(10002)');
	vrfy(2 + "x" == error(10003),	'3605: 2 + "x" == error(10003)');
	vrfy("x" - 2 == error(10004),	'3606: "x" - 2 == error(10004)');
	vrfy("x" * 2 == error(10005),	'3607: "x" * 2 == error(10005)');
	vrfy("x" / 2 == error(10006),	'3608: "x" / 2 == error(10006)');
	vrfy(-"x" == error(10007),	'3609: -"x" == error(10007)');
	vrfy("x"^2 == error(10008),	'3610: "x"^2 == error(10008)');
	vrfy(inverse("x")==error(10009),'3611: inverse("x") == error(10009)');
	vrfy(++strx == error(10010),	'3612: ++strx == error(10010)');
	vrfy(strx == error(10010),	'3613: strx == error(10010)');
	strx = "x";
	print				'3614: strx = "x"';
	vrfy(strx++ == "x",		'3615: strx++ == "x"');
	vrfy(strx == error(10010),	'3616: strx == error(10010)');
	strx = "x";
	print				'3617: strx = "x"';
	vrfy(--strx == error(10011),	'3618: strx == error(10011)');
	vrfy(int("x") == error(10012),	'3619: int("x") == error(10012)');
	vrfy(frac("x") == error(10013),	'3620: frac("x") == error(10013)');
	vrfy(conj("x") == error(10014),	'3621: conj("x") == error(10014)');
	vrfy(appr("x",.1) == error(10015),
				    '3622: appr("x",.1) == error(10015)');
	vrfy(appr(1.27,.1i) == error(10016),
				    '3623: appr(1.27,.1i) == error(10016)');
	vrfy(appr(1.27,.1,.1) == error(10017),
				    '3624: appr(1.27,.1,.1) == error(10017)');
	vrfy(round("x") == error(10018), '3625: round("x") == error(10018)');
	vrfy(round(1.25,.1) == error(10019),
				    '3626: round(1.25,.1) == error(10019)');
	vrfy(round(1.25,"x") == error(10019),
				    '3627: round(1.25,"x") == error(10019)');
	vrfy(round(1.25,1,.1) == error(10020),
				    '3628: round(1.25,1,.1) == error(10020)');
	vrfy(bround("x") == error(10021), '3629: bround("x") == error(10021)');
	vrfy(bround(1.25,.1) == error(10022),
				    '3630: bround(1.25,.1) == error(10022)');
	vrfy(bround(1.25,"x") == error(10022),
				    '3631: bround(1.25,"x") == error(10022)');
	vrfy(bround(1.25,1,.1) == error(10023),
				    '3632: bround(1.25,1,.1) == error(10023)');
	vrfy(sqrt("x") == error(10024),	'3633: sqrt("x") == error(10024)');
	vrfy(sqrt(2,"x") == error(10025),
				    '3634: sqrt(2,"x") == error(10025)');
	vrfy(sqrt(2,0) == error(10025),	   '3635: sqrt(2,0) == error(10025)');
	vrfy(sqrt(2,.1,.1) == error(10026),
				    '3636: sqrt(2,.1,.1) == error(10026)');
	vrfy(root("x",3) == error(10027),
				    '3637: root("x",3) == error(10027)');
	vrfy(root(3,"x") == error(10028),
				    '3638: root(3,"x") == error(10028)');
	vrfy(root(3,-2) == error(10028),
				    '3639: root(3,-2) == error(10028)');
	vrfy(root(3,0) == error(10028),	'3640: root(3,0) == error(10028)');
	vrfy(root(3,.1) == error(10028),
				    '3641: root(3,.1) == error(10028)');
	vrfy(root(3,2,"x") == error(10029),
				    '3642: root(3,2,"x") == error(10029)');
	vrfy(root(3,2,0) == error(10029),
				    '3643: root(3,2,0) == error(10029)');
	vrfy(norm("x") == error(10030),	'3644: norm("x") == error(10030)');
	vrfy("x" << 2 == error(10031),	'3645: "x" << 2 == error(10031)');
	vrfy(1.5 << 2 == error(10031),	'3646: 1.5 << 2 == error(10031)');
	vrfy(3 << "x" == error(10032),	'3647: 3 << "x" == error(10032)');
	vrfy(3 << 1.5 == error(10032),	'3648: 3 << 1.5 == error(10032)');
	vrfy(3 << 2^31 == error(10032),	'3649: 3 << 2^31 == error(10032)');
	vrfy(scale("x",2) == error(10033),
				    '3650: scale("x",2) == error(10033)');
	vrfy(scale(3,"x") == error(10034),
				    '3651: scale(3,"x") == error(10034)');
	vrfy(scale(3,1.5) == error(10034),
				    '3652: scale(3,1.5) == error(10034)');
	vrfy(scale(3,2^31) == error(10034),
				    '3653: scale(3,2^31) == error(10034)');
	vrfy("x" ^ 3 == error(10035),	'3654: "x" ^ 3 == error(10035)');
	vrfy(2 ^ "x" == error(10036),	'3655: 2 ^ "x" == error(10036)');
	vrfy(2 ^ 2.5 == error(10036),	'3656: 2 ^ 2.5 == error(10036)');
	vrfy(power("x",2.1) == error(10037),
					'3657: power("x",2.1) == error(10037)');
	vrfy(power(2,"x") == error(10038),
				    '3658: power(2,"x") == error(10038)');
	vrfy(power(2,2.1,"x") == error(10039),
				    '3659: power(2,2.1,"x") == error(10039)');
	vrfy(quo("x",3) == error(10040), '3660: quo("x",3) == error(10040)');
	vrfy(quo(8,"x") == error(10041), '3661: quo(8,"x") == error(10041)');
	vrfy(quo(8,3,"x") == error(10042),
				    '3662: quo(8,3,"x") == error(10042)');
	vrfy(quo(8,3,2.1) == error(10042),
				    '3663: quo(8,3,2.1) == error(10042)');
	vrfy(mod("x",3) == error(10043), '3664: mod("x",3) == error(10043)');
	vrfy(mod(8,"x") == error(10044), '3665: mod(8,"x") == error(10044)');
	vrfy(mod(8,3,"x") == error(10045),
				    '3666: mod(8,3,"x") == error(10045)');
	vrfy(mod(8,3,2.1) == error(10045),
				    '3667: mod(8,3,2.1) == error(10045)');
	vrfy(sgn("x") == error(10046),	'3668: sgn("x") == error(10046)');
	vrfy(abs("x") == error(10047),	'3669: abs("x") == error(10047)');
	vrfy(abs(2+3i,"x") == error(10048),
				    '3670: abs(2+3i,"x") == error(10048)');
	vrfy(abs(2+3i,0) == error(10048),
				    '3671: abs(2+3i,0) == error(10048)');
	list1 = list(2,3,"x",4,5);
	print			    '3672: list1 = list(2,3,"x",4,5)';
	vrfy(avg(list1) == error(10003),
				    '3673: avg(list1) == error(10003)');

	vrfy(iserror(e99)==99,		'3674: iserror(e99) == 99');
	vrfy(e99 + 2 == e99,		'3675: e99 + 2 == e99');
	vrfy(e99 - 2 == e99,		'3676: e99 - 2 == e99');
	vrfy(e99 * 2 == e99,		'3677: e99 * 2 == e99');
	vrfy(e99 / 2 == e99,		'3678: e99 / 2 == e99');
	vrfy(e99 // 2 == e99,		'3679: e99 // 2 == e99');
	vrfy(e99 % 2 == e99,		'3680: e99 % 2 == e99');
	vrfy(e99 ^ 2 == e99,		'3681: e99 ^ 2 == e99');
	vrfy(2 + e99 == e99,		'3682: 2 + e99 == e99');
	vrfy(2 - e99 == e99,		'3683: 2 - e99 == e99');
	vrfy(2 * e99 == e99,		'3684: 2 * e99 == e99');
	vrfy(2 / e99 == e99,		'3685: 2 / e99 == e99');
	vrfy(2 // e99 == e99,		'3686: 2 // e99 == e99');
	vrfy(2 % e99 == e99,		'3687: 2 % e99 == e99');
	vrfy(2 ^ e99 == e99,		'3688: 2 ^ e99 == e99');
	vrfy(- e99 == e99,		'3689: -e99 == e99');
	vrfy(inverse(e99) == e99,	'3690: inverse(e99) == e99');
	vrfy(++e99 == e99,		'3691: ++e99 == e99');
	vrfy(--e99 == e99,		'3692: --e99 == e99');
	vrfy(int(e99) == e99,		'3693: int(e99) == e99');
	vrfy(frac(e99) == e99,		'3694: frac(e99) == e99');
	vrfy(conj(e99) == e99,		'3695: conj(e99) == e99');
	vrfy(norm(e99) == e99,		'3696: norm(e99) == e99');
	vrfy(sgn(e99) == e99,		'3697: sgn(e99) == e99');
	vrfy(appr(e99,1,0) == e99,	'3698: appr(e99,1,0) == e99');
	vrfy(round(e99) == e99,		'3699: round(e99) == e99');
	vrfy(bround(e99) == e99,	'3700: bround(e99) == e99');
	vrfy(sqrt(e99) == e99,		'3701: sqrt(e99) == e99');

	print '3702: Ending test_error';
}
print '054: parsed test_error()';


/*
 * test_param - test new param() functionality.
 */
define g_param() = (param(2) = param(1));
print '055: define g_param() = (param(2) = param(1))';
define h_param() = (param(1)++, param(2)--);
print '056: define h_param() = (param(1)++, param(2)--)';
/**/
global u_glob = 5;
print '057: global u_glob = 5';
global v_glob = 10;
print '058: global v_glob = 10';
vrfy(g_param(u_glob, &v_glob) == 5,	'059: g_param(u_glob, &v_glob) == 5');
vrfy(u_glob == 5,			'060: u_glob == 5');
vrfy(v_glob == 5,			'061: v_glob == 5');
vrfy(h_param(&u_glob, &v_glob) == 5,	'062: h_param(&u_glob, &v_glob) == 5');
vrfy(u_glob == 6,			'063: u_glob == 6');
vrfy(v_glob == 4,			'064: v_glob == 4');
/**/
define test_param()
{
	local u, v;

	print '3800: Beginning test_param';

	u = 5;
	print				'3801: u = 5';
	v = 10;
	print				'3802: v = 10';
	vrfy(g_param(u, &v) == 5,	'3803: g_param(u, &v) == 5');
	vrfy(u == 5,			'3804: u == 5');
	vrfy(v == 5,			'3805: v == 5');
	vrfy(h_param(&u, &v) == 5,	'3806: h_param(&u, &v) == 5');
	vrfy(u == 6,			'3807: u == 6');
	vrfy(v == 4,			'3808: v == 4');

	print '3809: Ending test_param';
}
print '065: parsed test_param()';


/*
 * test_noarg - test missing argment functionality
 */
define test_noarg()
{
	local A,B,C,D;

	print '3900: Beginning test_noarg';

	A = list(1,,3);
	print				'3901: A = list(1,,3)';
	vrfy(A[[0]] == 1,		'3902: A[[0]] == 1');
	vrfy(isnull(A[[1]]),		'3903: isnull(A[[1]])');
	vrfy(A[[2]] == 3,		'3904: A[[2]] == 3');
	vrfy(size(A) == 3,		'3905: size(A) == 3');

	B = list(,,);
	print				'3906: B = list(,,)';
	vrfy(isnull(B[[0]]),		'3907: isnull(B[[0]])');
	vrfy(isnull(B[[1]]),		'3908: isnull(B[[1]])');
	vrfy(isnull(B[[2]]),		'3909: isnull(B[[2]])');
	vrfy(size(B) == 3,		'3910: size(B) == 3');

	mat C[] = {,,};
	print				'3911: mat C[] = {,,}';
	vrfy(C[0] == 0,			'3912: C[0] == 0');
	vrfy(C[1] == 0,			'3913: C[1] == 0');
	vrfy(C[2] == 0,			'3914: C[2] == 0');
	vrfy(size(C) == 3,		'3915: size(C) == 3');

	mat D[] = { };
	print				'3916: mat D[] = { }';
	vrfy(D[0] == 0,			'3917: D[0] == 0');
	vrfy(size(D) == 1,		'3918: size(D) == 1');
	print '3919: Ending test_noarg';
}
print '066: parsed test_noarg';


/*
 * test_ptest - more tests of the functions ptest, nextcand, prevcand
 */
read -once "test4000";
print '067: read -once test4000';
/**/
define test_ptest()
{
	local tnum;	/* test number */

	print '4000: Beginning test_ptest';

	tnum = test4000(1, 4001);

	print tnum: ': Ending test_ptest';
}
print '068: parsed test_ptest()';


/*
 * test_redc - REDC operation tests
 */
read -once "test4100";
print '069: read -once test4100';
/**/
define test_redc()
{
	local tnum;	/* test number */

	print '4100: Beginning test_redc';

	tnum = test4100(1, 4101);

	print tnum: ': Ending test_redc';
}
print '070: parsed test_redc()';


/*
 * test_fileops - test various file operations
 */
define test_fileops()
{
	local a, b, c, f, m, n, x, y, z;
	local L = "Landon";
	local C = "Curt";
	local N = "Noll";
	local LCN = "Landon\nCurt\nNoll\n";

	print '4200: Beginning test_fileops';

	/*
	 * fputs tests
	 */
	print				'4201: x = rm("junk4200")';
	x = rm("junk4200");
	vrfy(!iserror(f = fopen("junk4200", "w+")),
		'4202: !iserror(f = fopen("junk4200", "w+"))');
	vrfy(!iserror(fputs(f, LCN)),	'4203: !iserror(fputs(f, LCN))');
	vrfy(isnull(rewind(f)),		'4204: isnull(rewind(f))');
	vrfy(fgetfield(f) == L,		'4205: fgetfield(f) == L');
	vrfy(fgetfield(f) == C,		'4206: fgetfield(f) == C');
	vrfy(fgetfield(f) == N,		'4207: fgetfield(f) == N');
	vrfy(isnull(fgetfield(f)),	'4208: isnull(fgetfield(f))');
	vrfy(isnull(rewind(f)),		'4209: isnull(rewind(f))');
	vrfy(fgetline(f) == L,		'4210: fgetline(f) == L');
	vrfy(fgetline(f) == C,		'4211: fgetline(f) == C');
	vrfy(fgetline(f) == N,		'4212: fgetline(f) == N');
	vrfy(isnull(fgetline(f)),	'4213: isnull(fgetline(f))');
	vrfy(isnull(rewind(f)),		'4214: isnull(rewind(f))');
	vrfy(fgets(f) == strcat(L,"\n"),'4215: fgets(f) == strcat(L,"\\n")');
	vrfy(fgets(f) == strcat(C,"\n"),'4216: fgets(f) == strcat(C,"\\n")');
	vrfy(fgets(f) == strcat(N,"\n"),'4217: fgets(f) == strcat(N,"\\n")');
	vrfy(isnull(fgets(f)),		'4218: isnull(fgets(f))');
	vrfy(isnull(rewind(f)),		'4219: isnull(rewind(f))');
	vrfy(fgetstr(f) == LCN,		'4220: fgetstr(f) == LCN');
	vrfy(isnull(fclose(f)),		'4221: isnull(fclose(f))');
	vrfy(isnull(fclose(f)),		'4222: isnull(fclose(f))');

	/*
	 * fgetstr tests
	 */
	vrfy(!iserror(f = fopen("junk4200", "w+")),
					'4223: !iserror(f)');

	vrfy(isnull(fputstr(f, L, C, N)),
					'4224: isnulll(fputstr(f, L, C, N))');
	vrfy(isnull(rewind(f)),		'4225: isnull(rewind(f))');
	vrfy(fgetstr(f) == L,		'4226: fgetstr(f) == L');
	vrfy(fgetstr(f) == C,		'4227: fgetstr(f) == C');
	vrfy(fgetstr(f) == N,		'4228: fgetstr(f) == N');
	vrfy(isnull(fgetstr(f)),	'4229: isnull(fgetstr(f))');
	n = ftell(f);
	print				'4230: n = ftell(f)';
	vrfy(isnull(fputs(f,L,"\n",C,"\n",N,"\n")),
		'4231: isnull(fputs(f,L,"\\n",C,"\\n",N,"\\n"))');
	fseek(f, n);
	print				'4232: fseek(f, n)';
	vrfy(fgetstr(f) == LCN,		'4233: fgetstr(f) == LCN');
	vrfy(isnull(fclose(f)),		'4234: isnull(fclose(f))');

	/*
	 * fscanf tests
	 */
	a = exp(27, 1e-1000);
	print				'4235: a = exp(27, 1e-1000)';
	b = sqrt(7 + 5i, 1e-2000);
	print				'4236: b = sqrt(7 + 5i, 1e-2000)';
	c = config("display", 1000);
	print				'4237: c = config("display", 1000)';
	vrfy(!iserror(f=fopen("junk4200","w+")),
				'4238: !iserror(f=fopen("junk4200","w+"))');
	vrfy(!iserror(fprintf(f, "%f\n\tand\n\t%r",a,b)),
		'4239: !iserror(fprintf(f, "%f\\n\\tand\\n\\t%r",a,b))');
	vrfy(isnull(rewind(f)),		'4240: isnull(rewind(f))');
	vrfy(fscanf(f,"%f and %r",x,y) == 2,
					'4241: fscanf(f,"%f and %r",x,y) == 2');
	vrfy(x == a && y == b,		'4242: x == a && y == b');
	vrfy(!iserror(freopen(f, "w+")),'4243: !iserror(freopen(f, "w+"))');
	L = "Landon\n";
	print				'4244: L = "Landon\\n"';
	C = "\tCurt\n";
	print				'4245: C = "\tCurt\\n"';
	N = "\t\tNoll\n";
	print				'4246: N = "\\t\\tNoll\\n"';
	vrfy(isnull(fputs(f, L, "|", C, "[", N, "]" )),
		'4247: isnull(fputs(f, L, "|", C, "[", N, "]" ))');
	vrfy(isnull(rewind(f)),		'4248: isnull(rewind(f))');
	vrfy(fscanf(f, "%[^|]%*c%[^[]%*c%[^]]", x,y,z) == 3,
			'4249: fscanf(f, "%[^|]%*c%[^[]%*c%[^]]", x,y,z) == 3');
	vrfy(x == L && y == C && z == N,
					'4250: x == L && y == C && z == N');
	vrfy(isnull(rewind(f)),		'4251: isnull(rewind(f))');
	vrfy(fscanf(f, "%*[^|]%*c%n%*[^[]%*c%n", m, n) == 2,
		'4252: fscanf(f, "%*[^|]%*c%n%*[^[]%*c%n", m, n) == 2');
	fseek(f, m);
	print				'4253: fseek(f, m)';
	vrfy(fscanf(f, "%3c", x) == 1,	'4254: fscanf(f, "%3c", x) == 1');
	vrfy(x == "\tCu",		'4255: x == "\tCu"');
	fseek(f, n);
	print				'4256: fseek(f, n)';
	vrfy(fscanf(f, "%s", y) == 1,	'4257: fscanf(f, "%s", y) == 1');
	vrfy(y == "Noll",		'4258: y == "Noll"');
	vrfy(isnull(fclose(f)),		'4259: isnull(fclose(f))');

	/*
	 * cleanup
	 */
	print				'4260: x = rm("junk4200")';
	x = rm("junk4200");

	print '4261: Ending test_fileops';
}
print '071: parsed test_redc()';


/*
 * test_matdcl - test new matrix declaration syntax
 */
mat_X0 = mat[4];
print '072: mat_X = mat[4]';
mat mat_X1, mat_X2[2], mat_X3[3];
print '073: mat mat_X1, mat_X2[2], mat_X3[3]';
mat mat_Z0, mat_Z1 [2] = {1,2};
print '074: mat mat_Z0, mat_Z1 [2] = {1,2}';
define test_matdcl()
{
	local mat_Y0;
	local mat mat_Y1, mat_Y2[2], mat_Y3[3];
	local mat M0, M1, M2[2,2];
	local i;

	print '4300: Beginning test_matdcl';

	vrfy(size(mat_X0) == 4,		    '4301: size(mat_X0) == 4');
	vrfy(size(mat_X1) == 2,		    '4302: size(mat_X1) == 2');
	vrfy(size(mat_X2) == 2,		    '4303: size(mat_X2) == 2');
	vrfy(size(mat_X3) == 3,		    '4304: size(mat_X3) == 3');
	vrfy(ismat(mat_X0),		    '4305: ismat(mat_X0)');
	vrfy(ismat(mat_X1),		    '4306: ismat(mat_X1)');
	vrfy(ismat(mat_X2),		    '4307: ismat(mat_X2)');
	vrfy(ismat(mat_X3),		    '4308: ismat(mat_X3)');
	mat_Y0 = mat[4];
	print 				    '4309: mat_Y0 = mat[4]';
	vrfy(size(mat_Y0) == 4,		    '4310: size(mat_Y0) == 4');
	vrfy(size(mat_Y1) == 2,		    '4311: size(mat_Y1) == 2');
	vrfy(size(mat_Y2) == 2,		    '4312: size(mat_Y2) == 2');
	vrfy(size(mat_Y3) == 3,		    '4313: size(mat_Y3) == 3');
	vrfy(ismat(mat_Y0),		    '4314: ismat(mat_Y0)');
	vrfy(ismat(mat_Y1),		    '4315: ismat(mat_Y1)');
	vrfy(ismat(mat_Y2),		    '4316: ismat(mat_Y2)');
	vrfy(ismat(mat_Y3),		    '4317: ismat(mat_Y3)');
	vrfy(size(mat_Z0) == 2,		    '4318: size(mat_Z0) == 2');
	vrfy(size(mat_Z1) == 2,		    '4319: size(mat_Z1) == 2');
	vrfy(ismat(mat_Z0),		    '4320: ismat(mat_Z0)');
	vrfy(ismat(mat_Z1),		    '4321: ismat(mat_Z1)');
	vrfy(mat_Z0 == mat_Z1,		    '4322: mat_Z0 == mat_Z1');
	vrfy(mat_Z0 == (mat[2] = {1,2}),    '4323: mat_Z0 == (mat[2] = {1,2})');
	vrfy(mat_Z0[0] == 1,		    '4324: mat_Z0[0] == 1');
	vrfy(mat_Z0[1] == 2,		    '4325: mat_Z0[1] == 2');
	mat_Z1 = {,3};
	print				    '4326: mat_Z1 = {,3}';
	vrfy(mat_Z0 != mat_Z1,		    '4327: mat_Z0 != mat_Z1');
	vrfy(mat_Z1[0] == 1,		    '4328: mat_Z1[0] == 1');
	vrfy(mat_Z1[1] == 3,		    '4329: mat_Z1[1] == 3');
	mat_X3 = {2,3,5};
	print				    '4330: mat_X3 = {2,3,5}';
	mat_X3 += {3,4,5};
	print				    '4331: mat_X3 += {3,4,5}';
	vrfy(mat_X3[0] == 5,		    '4332: mat_X3[0] == 5');
	vrfy(mat_X3[1] == 7,		    '4333: mat_X3[1] == 7');
	vrfy(mat_X3[2] == 10,		    '4334: mat_X3[2] == 10');
	mat_Y3 = mat_X3;
	print				    '4335: mat_Y3 = mat_X3';
	mat_Y3 -= {,1,2};
	print				    '4336: mat_Y3 -= {0,1,}';
	vrfy(mat_Y3[0] == 0,		    '4337: mat_Y3[0] == 0');
	vrfy(mat_Y3[1] == 6,		    '4338: mat_Y3[1] == 6');
	vrfy(mat_Y3[2] == 8,		    '4339: mat_Y3[2] == 8');
	mat_Y3 += 2;
	print				    '4340: mat_Y3 += 2';
	vrfy(mat_Y3 == error(10003),	    '4341: mat_Y3 == error(10003)');
	mat_Z0 += { };
	print				    '4342: mat_Z0 += { }';
	vrfy(mat_Z0[0] == 2,		    '4343: mat_Z0[0] == 2');
	vrfy(mat_Z0[1] == 4,		    '4344: mat_Z0[1] == 4');
	mat_Y0 = {mat_Z0, ,mat_Z1, mat_X3};
	print			'4345: mat_Y0 = {mat_Z0, ,mat_Z1, mat_X3}';
	vrfy(size(mat_Y0) == 4,		    '4346: size(mat_Y0) == 4');
	for (i=0; i < 4; ++i) mat_X0[i] = size(mat_Y0[i]);
	print '4347: for (i=0; i < 4; ++i) mat_X0[i] = size(mat_Y0[i])';
	mat_X0==(mat[4]={2,1,2,3});
	print			    	    '4348: mat_X0==(mat[4]={2,1,2,3})';
	vrfy(mat_Y0[0] == mat_Z0,	    '4349: mat_Y0[0] == mat_Z0');
	vrfy(mat_Y0[1] == 0,	    	    '4350: mat_Y0[1] == 0');
	vrfy(mat_Y0[2] == mat_Z1,	    '4351: mat_Y0[2] == mat_Z1');
	vrfy(mat_Y0[3] == mat_X3,	    '4352: mat_Y0[3] == mat_X3');
	vrfy(mat_Y0[0][0] == 2,		    '4353: mat_Y0[0][0] == 2');
	vrfy(mat_Y0[0][1] == 4,		    '4354: mat_Y0[0][1] == 4');
	vrfy(mat_Y0[2][0] == 1,		    '4355: mat_Y0[2][0] == 1');
	vrfy(mat_Y0[2][1] == 3,		    '4356: mat_Y0[2][1] == 3');
	vrfy(mat_Y0[3][0] == 5,		    '4357: mat_Y0[3][0] == 5');
	vrfy(mat_Y0[3][1] == 7,		    '4358: mat_Y0[3][1] == 7');
	vrfy(mat_Y0[3][2] == 10,	    '4359: mat_Y0[3][2] == 10');

	M0 = {(mat[2]={5,17}),(mat[2]={3,4}),(mat[2]={2,3}),(mat[2]={1,2})};
	print				    '4360: M0 = {(mat[2]={5,17}), ...}';
	M1 = {(mat[2]={5,3}),(mat[2]={2,5}),(mat[2]={1,5}),(mat[2]={3,2})};
	print				    '4361: M1 = {(mat[2]={5,3}), ...}';
	M2 = M0+M1;
	print				    '4362: M2 = M0+M1';
	vrfy(M2[0,0]==(mat[2]={10,20}),	    '4363: M2[0,0]==(mat[2]={10,20})');
	vrfy(M2[0,1]==(mat[2]={5,9}),	    '4364: M2[0,1]==(mat[2]={5,9})');
	vrfy(M2[1,0]==(mat[2]={3,8}),	    '4365: M2[1,0]==(mat[2]={3,20})');
	vrfy(M2[1,1]==(mat[2]={4,4}),	    '4366: M2[1,1]==(mat[2]={4,4})');

	print '4367: Ending test_matdcl';
}
print '075: parsed test_matdcl()';


/*
 * test_objmat - test combined obj and mat operations
 */
define test_objmat()
{
	static obj surd P, R, S, T, U;
	local mat M0[2] = {5,17};
	local mat M1[2] = {3,4};
	local mat M2[2,2] = {1,2,3,5};
	local mat M3[2,2] = {3,5,7,11};
	local mat M4[2,2] = {51,82,116,187};
	local Q;
	local V;
	local A,B,C,M;

	print '4400: Beginning test_objmat';

	surd_type = -1;
	print				    '4401: surd_type == -1';
	P = {M0,M1};
	print				    '4402: P = {M0,M1}';
	vrfy(P == surd(M0,M1),		    '4403: P == surd(M0,M1)');
	vrfy(P != surd(M1,M0),		    '4404: P == surd(M1,M0)');
	vrfy(conj(P)==surd(M0,-M1),	    '4405: conj(P)==surd(M0,-M1)');
	Q = surd_value(P);
	print				    '4406: Q = surd_value(P)';
	vrfy(ismat(Q),			    '4407: ismat(Q)');
	vrfy(Q == (mat[2]={5+3i,17+4i}),    '4408: Q == (mat[2]={5+3i,17+4i})');
	R = {M2,M3};
	print				    '4409: R = {M2,M3}';
	vrfy(norm(R) == M4,	    	    '4410: norm(R) == M4');
	vrfy(det(surd_value(R^2)) == -23-6i, \
				'4411: det(surd_value(R^2)) == -23-6i');
	vrfy(det(norm(R^5))==268107761663283843865, \
				'4412: det(norm(R^5))==268107761663283843865');
	S = {M2+M3, M2-M3};
	print				    '4413: S = {M2+M3, M2-M3}';
	T = {M2+3*M3, 5*M2-M3};
	print				    '4414: T = {M2+3*M3, 5*M2-M3}';
	U = {(M4 -= {50,80,110,180}), M4+M2};
	print			'4415: U = {(M4 -= {50,80,110,180}), M4+M2}';
	vrfy(det(surd_value(R*S*T*U)) == 480-15040i,
				'4416: det(surd_value(R*S*T*U)) == 480-15040i');
	vrfy(det(surd_value(R*S+T*U)) == 78+514i,
				'4417: det(surd_value(R*S+T*U)) == 78+514i');
	V = norm(det(surd_value(R^5+S^5+T^5+U^5)));
	print		'4418: V = norm(det(surd_value(R^5+S^5+T^5+U^5)))';
	vrfy(V == 41952632964892462488299378, \
			'4419: V == 41952632964892462488299378');
	V = norm(det(surd_value(R^5-S^5+T^5-U^5)));
	print		'4420: V = norm(det(surd_value(R^5-S^5+T^5-U^5)))';
	vrfy(V == 40891924356202870926321650, \
			'4421: V == 40891924356202870926321650');


	vrfy((mat [3] = {2,3,5})+(mat[3] = {7,11,13}) == (mat[3]={9,14,18}),\
      '4422: (mat [3] = {2,3,5})+(mat[3] = {7,11,13}) == (mat[3]={9,14,18})');

	vrfy((mat [2,2] = {2,3,5,7})^2 == (mat[2,2] = {19, 27, 45, 64}),\
	    '4423: (mat [2,2] = {2,3,5,7})^2 == (mat[2,2] = {19, 27, 45, 64})');

	vrfy((mat [] = {1,2,3}) == (mat[3] = {1,2,3}),
	    '4424: (mat [] = {1,2,3}) == (mat[3] = {1,2,3})');

	mat A[3] = {2,3,5};
	print 			    '4425: mat A[3] = {2,3,5}';
	mat A[3] = {A[0], A[2], A[1]};
	print			    '4426: mat A[3] = {A[0], A[2], A[1]}';
	vrfy(A == (mat[3] = {2, 5, 3}),	    '4427: A == (mat[3] = {2, 5, 3})');

	B = mat[3] = {2,5,3};
	print			    	    '4428: B = mat[3] = {2,5,3}';
	vrfy(A == B,			    '4429: A == B');

	mat A[2] = {A[1], A[2]};
	print				    '4430: mat A[2] = {A[1], A[2]}';
	vrfy(A == (mat[2] = {5, 3}),	    '4431: A == (mat[2] = {5, 3})');

	A = B;
	print				    '4432: A = B';
	A = {A[0], A[2], A[1]};
	print				    '4433: A = {A[0], A[2], A[1]}';
	vrfy(A == (mat[3] = {2, 3, 3}),	    '4434: A == (mat[3] = {2, 3, 3})');

	A = mat[3] = {1,2} = {,3,4};
	print				    '4435: A = mat[3] = {1,2} = {,3,4}';
	vrfy(A == (mat[3] = {1,3,4}),	    '4436: A == (mat[3] = {1,3,4})');

	mat A[4] = {1,2,3,4};
	print				    '4437: mat A[4] = {1,2,3,4}';
	A = {,5,,6};
	print				    '4438: A = {,5,,6}';
	vrfy(A == (mat[4] = {1,5,3,6}),	    '4439: A == (mat[4] = {1,5,3,6})');

	A = {7};
	print				    '4440: A = {7}';
	vrfy(A == (mat[4] = {7,5,3,6}),	    '4441: A == (mat[4] = {7,5,3,6})');

	mat M[2];
	print				    '4442: mat M[2]';
	mat A, B, C [3] = {M, M, M};
	print			    '4443: mat A, B, C [3] = {M, M, M}';

	A = {{2, 3}, {5, 7}, {11, 13}};
	print			    '4444: A = {{2, 3}, {5, 7}, {11, 13}}';
	B = {{1, 2}, {3, 4}, {5, 6}};
	print			    '4445: B = {{1, 2}, {3, 4}, {5, 6}}';
	C = {{3, 5}, {8, 11}, {16, 19}};
	print			    '4446: C = {{3, 5}, {8, 11}, {16, 19}}';

	vrfy(A + B == C,		    '4447: A + B == C');

	mat A[2][3];
	print				    '4448: mat A[2][3]';
	A = {{1, 2, 3}, {4, 5, 6}};
	print				    '4449: A = {{1, 2, 3}, {4, 5, 6}}';
	vrfy(A[0][1] == 2,		    '4450: A[0][1] == 2');

	vrfy(A[1,0] == 4,		    '4451: A[1,0] == 4');

	B = mat[2][3] = {{1, 2, 3}, {4, 5, 6}};
	print			'4452: B = mat[2][3] = {{1, 2, 3}, {4, 5, 6}}';
	vrfy(A == B,			    '4453: A == B');

	mat A[2][3] = {{1, 2, 3}, {4, 5, 6}};
	print			'4454: mat A[2][3] = {{1, 2, 3}, {4, 5, 6}}';
	vrfy(A == B,			    '4455: A == B');

	mat A[2][3] = {{1,2,3},4};
	print				    '4456: mat A[2][3] = {{1,2,3},4}';
	vrfy(A[0] == (mat[3] = {1,2,3}),    '4457: A[0] == (mat[3] = {1,2,3})');

	vrfy(A[1] == 4,			    '4458: A[1] == 4');

	A += {{3,5,7}, 11};
	print				    '4459: A += {{3,5,7}, 11}';

	vrfy(A[0] == (mat[3]={4,7,10}),	    '4460: A[0] == (mat[3]={4,7,10})');

	vrfy(A[1] == 15,		    '4461: A[1] == 15');

	mat A[2,2][2,2]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
 print '4462: mat A[2,2][2,2]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}';
	B = A^2;
	print				    '4463: B = A^2';
	
	vrfy(B[0,0] == (mat[2,2] = {118, 132, 166, 188}), \
			'4464: B[0,0] == (mat[2,2] = {118, 132, 166, 188})');

	print '4465: Ending test_objmat';
	print;
	print '4500: reserved for future expansion of test_objmat';
}
print '076: parsed test_objmat()';


/*
 * test_fileop - test file operations
 */
read -once "test4600";
print '077: read -once test4600';
/**/
define test_fileop()
{
	local tnum;	/* test number */

	print '4600: Beginning test_fileop';

	tnum = test4600(1, 4601);

	print tnum: ': Ending test_fileop';
}
print '078: parsed test_fileop()';


/*
 * test write/read
 */
x_081 = isqrt(2e5000);
print '079: x_081 = isqrt(2e5000)'
s_x_081 = str(x_081);
print '080: s_x_081 = str(x_081)';
d_081 = rm("test082.cal");
print '081: d_081 = rm("test082.cal")';
write test082.cal;
print '082: write test082.cal';
read "./test082.cal";
print '083: read "./test082.cal"';
d_081 = rm("test082.cal");
print '084: d081 = rm("test082.cal")';
vrfy(__ == 63,				    '085: __ == 63');
vrfy(x_081 == isqrt(2e5000),		    '086: x_081 == isqrt(2e5000)');


/*
 * test_charset - test the ASCII character set and \'s
 */
define test_charset()
{
	print '4700: Beginning test_charset';

	vrfy("\a" == char(7),		    '4701: "\\a" == char(7)');
	vrfy("\v" == char(11),		    '4702: "\\v" == char(11)');
	vrfy("\e" == char(27),		    '4703: "\\e" == char(27)');
	vrfy("\\" == char(92),		    '4704: "\\\\" == char(92)');
	vrfy("\101" == "A",		    '4705: "\\101" == "A"');
	vrfy("\123" == char(0123),	    '4706: "\\123" == char(0123)');
	vrfy("\123\124" == "ST",	    '4707: "\\123\\124" == "ST"');
	vrfy("\311" == char(201),	    '4708: "\\311" == char(201)');
	vrfy("\119" == "\t9",		    '4709: "\\119" == "\t9"');
	vrfy("\765" == "\365",		    '4710: "\\765" == "\365"');
	vrfy("\x61" == "a",		    '4711: "\\x61" == "a"');
	vrfy("\x73" == "s",		    '4712: "\\x73" == "s"');
	vrfy("\xea" == char(234),	    '4713: "\\xea" == char(234)');
	vrfy("\x61\x62\x63" == "abc",	    '4714: "\\x61\\x62\\x63" == "abc"');
	vrfy("\x8g" == "\bg",		    '4715: "\\x8g" == "\bg"');
	vrfy(eval('"\\\\"') == "\\",
				'4716: eval(\'"\\\\\\\\"\') == "\\\\"');

	print '4717: Ending test_charset';
}
print '087: parsed test_fileop()';


/*
 * test_strprintf - test strprintf calls
 */
define test_strprintf()
{
	local callcfg;		/* caller configuration value */
	local c;		/* modified configuration */

	print '4800: Beginning test_strprintf';

	/* setup */
	callcfg = config("all");
	print				    '4801: callcfg = config("all")';
	c = config("mode", "frac");
	print				    '4802: c = config("mode", "frac")';
	c = config("outround", 24);
	print				    '4803: c = config("outround", 24)';
	c = config("display", 2);
	print				    '4804: c = config("display", 2)';
	c = config("tilde", 0);
	print				    '4805: c = config("tilde", 0)';
	c = config("leadzero", 0);
	print				    '4806: c = config("leadzero", 0)';
	c = config("fullzero", 0);
	print				    '4807: c = config("fullzero", 0)';

	/* tests with tilde == 0 */
	vrfy(strprintf("%d%d", 27, 29) == "2729",
			'4808: strprintf("%d%d", 27, 29) == "2729"');
	vrfy(strprintf("%5d%3d", 27, 29) == "   27 29",
			'4809: strprintf("%5d%3d", 27, 29) == "   27 29"; ');
	vrfy(strprintf("%-5d%-3d", 27, 29) == "27   29 ",
			'4810: strprintf("%-5d%-3d", 27, 29) == "27   29 "');
	vrfy(strprintf("%f", 1.375) == "1.38",
			'4811: strprintf("%f", 1.375) == "1.38"');
	vrfy(strprintf("%f", 1.385) == "1.38",
			'4812: strprintf("%f", 1.385) == "1.38"');
	vrfy(strprintf("%f", .375) == ".38",
			'4813: strprintf("%f", .375) == ".38"');
	vrfy(strprintf("%f", .385) == ".38",
			'4814: strprintf("%f", .385) == ".38"');

	/* tests with tilde == 1 */
	c = config("tilde", 1);
	print		'4815: c = config("tilde", 1)';
	vrfy(strprintf("%f", 1.375) == "~1.38",
			'4816: strprintf("%f", 1.375) == "~1.38"');
	vrfy(strprintf("%f", 27/29) == "~.93",
			'4817: strprintf("%f", 27/29) == "~.93"');
	vrfy(strprintf("%r", 27/29) == "27/29",
			'4818: strprintf("%r", 27/29) == "27/29"');
	vrfy(strprintf("%o", 27/29) == "033/035",
			'4819: strprintf("%o", 27/29) == "033/035"');
	vrfy(strprintf("%x", 27/29) == "0x1b/0x1d",
			'4820: strprintf("%x", 27/29) == "0x1b/0x1d"');
	vrfy(strprintf("%b", 27/29) == "0b11011/0b11101",
			'4821: strprintf("%b", 27/29) == "0b11011/0b11101"');
	vrfy(strprintf("%e", 12345) == "~1.23e4",
			'4822: strprintf("%e", 12345) == "~1.23e4"');

	/* mode tests with tilde == 0 */
	c = config("tilde", 0);
	print		'4823: c = config("tilde", 0)';
	vrfy(strprintf("%e", 12345) == "1.23e4",
			'4824: strprintf("%e", 12345) == "1.23e4"');
	vrfy(strprintf("%.3e", 12345) == "1.234e4",
			'4825: strprintf("%.3e", 12345) == "1.234e4"');
	vrfy(strprintf("%e", .00012345) == "1.23e-4",
			'4826: strprintf("%e", .00012345) == "1.23e-4"');
	vrfy(strprintf("%d %d", 27) == "27 ",
			'4827: strprintf("%d %d", 27) == "27 "');
	vrfy(strprintf("%d", 27, 29) == "27",
			'4828: strprintf("%d", 27, 29) == "27"');
	vrfy(strprintf("%r = %f", 27/29, 27/29) == "27/29 = .93",
		'4829: strprintf("%r = %f", 27/29, 27/29) == "27/29 = .93"');
	vrfy(strprintf("%s", "abc") == "abc",
		'4830: strprintf("%s", "abc") == "abc"');
	vrfy(strprintf("%f", "abc") == "abc",
		'4831: strprintf("%f", "abc") == "abc"');
	vrfy(strprintf("%e", "abc") == "abc",
		'4832: strprintf("%e", "abc") == "abc"');
	vrfy(strprintf("%5s", "abc") == "  abc",
		'4833: strprintf("%5s", "abc") == "  abc"');
	vrfy(strprintf("%-5s", "abc") == "abc  ",
		'4834: strprintf("%-5s", "abc") == "abc  "');

	/* restore config */
	c = config("all", callcfg);
	print				    '4835: c = config("all", callcfg)';

	print '4836: Ending test_strprintf';
}
print '088: parsed test_fileop()';


/*
 * place holder for any print items
 */
print '100: reserved for future use';


/*
 * Report the number of errors found.
 */
define count_errors()
{
	if (err  ==  0) {
		print "9998: passed all tests  /\\../\\";
	} else {
		print "****", err, "error(s) found  \\/++\\/";
	}
}
print '198: parsed count_errors()';


print '199: Ending main part of regression test suite read';


print;
return test_booleans();
print;
return test_variables();
print;
return test_arithmetic();
print;
return test_config();
print;
return test_bignums();
print;
return test_functions();
print;
return _test_underscore();
print;
return test_assoc();
print;
return test_list();
print;
return test_rand();
print;
return test_mode();
print;
print '1700: Beginning read test';
value = 0;
vrfy(value == 0,	'1701: value == 0');
read "test1700";
vrfy(value == 1,	'1702: value == 1');
read -once "test1700";
vrfy(value == 1,	'1703: value == 1');
read "test1700.cal";
vrfy(value == 2,	'1704: value == 2');
read -once "test1700.cal";
vrfy(value == 2,	'1705: value == 2');
read "test1700.cal";
vrfy(value == 3,	'1706: value == 3');
print '1707: Ending read test';
print;
return test_obj();
print;
return test_prime();
print;
return test_lucas();
print;
return test_newop();
print;
return test_xx_incdec();
print;
return test_round();
print;
return test_2600();
print;
return test_2700();
print;
return test_matrix();
print;
return test_strings();
print;
return test_matobj();
print;
return test_poly();
print;
return test_det();
print;
return test_trig();
print;
return test_frem();
print;
return test_error();
print;
return test_param();
print;
return test_noarg();
print;
return test_ptest();
print;
return test_redc();
print;
return test_fileops();
print;
return test_matdcl();
print;
return test_objmat();
print;
return test_fileop();
print;
return test_charset();
print;
return test_strprintf();
print;
return count_errors();
print '9999: Ending regression tests';