// This file is automatically generated by scheme2js, except for the

// benchmark harness code at the beginning and end of the file.

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/************* GENERATED FILE - DO NOT EDIT *************/

/*

 * To use write/prints/... the default-output port has to be set first.

 * Simply setting SC_DEFAULT_OUT and SC_ERROR_OUT to the desired values

 * should do the trick.

 * In the following example the std-out and error-port are redirected to

 * a DIV.

function initRuntime() {

    function escapeHTML(s) {

	var tmp = s;

	tmp = tmp.replace(/&/g, "&");

	tmp = tmp.replace(/</g, "&lt;");

	tmp = tmp.replace(/>/g, ">");

	tmp = tmp.replace(/ /g, " ");

	tmp = tmp.replace(/\n/g, "<br />");

	tmp = tmp.replace(/\t/g, "   &nbsp");

	return tmp;

    }

    document.write("<div id='stdout'></div>");

    SC_DEFAULT_OUT = new sc_GenericOutputPort(

	function(s) {

	    var stdout = document.getElementById('stdout');

	    stdout.innerHTML = stdout.innerHTML + escapeHTML(s);

	});

    SC_ERROR_OUT = SC_DEFAULT_OUT;

}

*/

function sc_print_debug() {

    sc_print.apply(null, arguments);

}

/*** META ((export *js*)) */

var sc_JS_GLOBALS = this;

var __sc_LINE=-1;

var __sc_FILE="";

/*** META ((export #t)) */

function sc_alert() {

   var len = arguments.length;

   var s = "";

   var i;

   for( i = 0; i < len; i++ ) {

       s += sc_toDisplayString(arguments[ i ]);

   }

   return alert( s );

}

/*** META ((export #t)) */

function sc_typeof( x ) {

   return typeof x;

}

/*** META ((export #t)) */

function sc_error() {

    var a = [sc_jsstring2symbol("*error*")];

    for (var i = 0; i < arguments.length; i++) {

	a[i+1] = arguments[i];

    }

    throw a;

}

/*** META ((export #t)

           (peephole (prefix "throw ")))

*/

function sc_raise(obj) {

    throw obj;

}

/*** META ((export with-handler-lambda)) */

function sc_withHandlerLambda(handler, body) {

    try {

	return body();

    } catch(e) {

	if (!e._internalException)

	    return handler(e);

	else

	    throw e;

    }

}

var sc_properties = new Object();

/*** META ((export #t)) */

function sc_putpropBang(sym, key, val) {

    var ht = sc_properties[sym];

    if (!ht) {

	ht = new Object();

	sc_properties[sym] = ht;

    }

    ht[key] = val;

}

/*** META ((export #t)) */

function sc_getprop(sym, key) {

    var ht = sc_properties[sym];

    if (ht) {

	if (key in ht)

	    return ht[key];

	else

	    return false;

    } else

	return false;

}

/*** META ((export #t)) */

function sc_rempropBang(sym, key) {

    var ht = sc_properties[sym];

    if (ht)

	delete ht[key];

}

/*** META ((export #t)) */

function sc_any2String(o) {

    return jsstring2string(sc_toDisplayString(o));

}    

/*** META ((export #t)

           (peephole (infix 2 2 "==="))

           (type bool))

*/

function sc_isEqv(o1, o2) {

    return (o1 === o2);

}

/*** META ((export #t)

           (peephole (infix 2 2 "==="))

           (type bool))

*/

function sc_isEq(o1, o2) {

    return (o1 === o2);

}

/*** META ((export #t)

           (type bool))

*/

function sc_isNumber(n) {

    return (typeof n === "number");

}

/*** META ((export #t)

           (type bool))

*/

function sc_isComplex(n) {

    return sc_isNumber(n);

}

/*** META ((export #t)

           (type bool))

*/

function sc_isReal(n) {

    return sc_isNumber(n);

}

/*** META ((export #t)

           (type bool))

*/

function sc_isRational(n) {

    return sc_isReal(n);

}

/*** META ((export #t)

           (type bool))

*/

function sc_isInteger(n) {

    return (parseInt(n) === n);

}

/*** META ((export #t)

           (type bool)

           (peephole (postfix ", false")))

*/

// we don't have exact numbers...

function sc_isExact(n) {

    return false;

}

/*** META ((export #t)

           (peephole (postfix ", true"))

	   (type bool))

*/

function sc_isInexact(n) {

    return true;

}

/*** META ((export = =fx =fl)

           (type bool)

           (peephole (infix 2 2 "===")))

*/

function sc_equal(x) {

    for (var i = 1; i < arguments.length; i++)

	if (x !== arguments[i])

	    return false;

    return true;

}

/*** META ((export < <fx <fl)

           (type bool)

           (peephole (infix 2 2 "<")))

*/

function sc_less(x) {

    for (var i = 1; i < arguments.length; i++) {

	if (x >= arguments[i])

	    return false;

	x = arguments[i];

    }

    return true;

}

/*** META ((export > >fx >fl)

           (type bool)

           (peephole (infix 2 2 ">")))

*/

function sc_greater(x, y) {

    for (var i = 1; i < arguments.length; i++) {

	if (x <= arguments[i])

	    return false;

	x = arguments[i];

    }

    return true;

}

/*** META ((export <= <=fx <=fl)

           (type bool)

           (peephole (infix 2 2 "<=")))

*/

function sc_lessEqual(x, y) {

    for (var i = 1; i < arguments.length; i++) {

	if (x > arguments[i])

	    return false;

	x = arguments[i];

    }

    return true;

}

/*** META ((export >= >=fl >=fx)

           (type bool)

           (peephole (infix 2 2 ">=")))

*/

function sc_greaterEqual(x, y) {

    for (var i = 1; i < arguments.length; i++) {

	if (x < arguments[i])

	    return false;

	x = arguments[i];

    }

    return true;

}

/*** META ((export #t)

           (type bool)

           (peephole (postfix "=== 0")))

*/

function sc_isZero(x) {

    return (x === 0);

}

/*** META ((export #t)

           (type bool)

           (peephole (postfix "> 0")))

*/

function sc_isPositive(x) {

    return (x > 0);

}

/*** META ((export #t)

           (type bool)

           (peephole (postfix "< 0")))

*/

function sc_isNegative(x) {

    return (x < 0);

}

/*** META ((export #t)

           (type bool)

           (peephole (postfix "%2===1")))

*/

function sc_isOdd(x) {

    return (x % 2 === 1);

}

/*** META ((export #t)

           (type bool)

           (peephole (postfix "%2===0")))

*/

function sc_isEven(x) {

    return (x % 2 === 0);

}

/*** META ((export #t)) */

var sc_max = Math.max;

/*** META ((export #t)) */

var sc_min = Math.min;

/*** META ((export + +fx +fl)

           (peephole (infix 0 #f "+" "0")))

*/

function sc_plus() {

    var sum = 0;

    for (var i = 0; i < arguments.length; i++)

	sum += arguments[i];

    return sum;

}

/*** META ((export * *fx *fl)

           (peephole (infix 0 #f "*" "1")))

*/

function sc_multi() {

    var product = 1;

    for (var i = 0; i < arguments.length; i++)

	product *= arguments[i];

    return product;

}

/*** META ((export - -fx -fl)

           (peephole (minus)))

*/

function sc_minus(x) {

    if (arguments.length === 1)

	return -x;

    else {

	var res = x;

	for (var i = 1; i < arguments.length; i++)

	    res -= arguments[i];

	return res;

    }

}

/*** META ((export / /fl)

           (peephole (div)))

*/

function sc_div(x) {

    if (arguments.length === 1)

	return 1/x;

    else {

	var res = x;

	for (var i = 1; i < arguments.length; i++)

	    res /= arguments[i];

	return res;

    }

}

/*** META ((export #t)) */

var sc_abs = Math.abs;

/*** META ((export quotient /fx)

           (peephole (hole 2 "parseInt(" x "/" y ")")))

*/

function sc_quotient(x, y) {

    return parseInt(x / y);

}

/*** META ((export #t)

           (peephole (infix 2 2 "%")))

*/

function sc_remainder(x, y) {

    return x % y;

}

/*** META ((export #t)

           (peephole (modulo)))

*/

function sc_modulo(x, y) {

    var remainder = x % y;

    // if they don't have the same sign

    if ((remainder * y) < 0)

	return remainder + y;

    else

	return remainder;

}

function sc_euclid_gcd(a, b) {

    var temp;

    if (a === 0) return b;

    if (b === 0) return a;

    if (a < 0) {a = -a;};

    if (b < 0) {b = -b;};

    if (b > a) {temp = a; a = b; b = temp;};

    while (true) {

	a %= b;

	if(a === 0) {return b;};

	b %= a;

	if(b === 0) {return a;};

    };

    return b;

}

/*** META ((export #t)) */

function sc_gcd() {

    var gcd = 0;

    for (var i = 0; i < arguments.length; i++)

	gcd = sc_euclid_gcd(gcd, arguments[i]);

    return gcd;

}

/*** META ((export #t)) */

function sc_lcm() {

    var lcm = 1;

    for (var i = 0; i < arguments.length; i++) {

	var f = Math.round(arguments[i] / sc_euclid_gcd(arguments[i], lcm));

	lcm *= Math.abs(f);

    }

    return lcm;

}

// LIMITATION: numerator and denominator don't make sense in floating point world.

//var SC_MAX_DECIMALS = 1000000

//

// function sc_numerator(x) {

//     var rounded = Math.round(x * SC_MAX_DECIMALS);

//     return Math.round(rounded / sc_euclid_gcd(rounded, SC_MAX_DECIMALS));

// }

// function sc_denominator(x) {

//     var rounded = Math.round(x * SC_MAX_DECIMALS);

//     return Math.round(SC_MAX_DECIMALS / sc_euclid_gcd(rounded, SC_MAX_DECIMALS));

// }

/*** META ((export #t)) */

var sc_floor = Math.floor;

/*** META ((export #t)) */

var sc_ceiling = Math.ceil;

/*** META ((export #t)) */

var sc_truncate = parseInt;

/*** META ((export #t)) */

var sc_round = Math.round;

// LIMITATION: sc_rationalize doesn't make sense in a floating point world.

/*** META ((export #t)) */

var sc_exp = Math.exp;

/*** META ((export #t)) */

var sc_log = Math.log;

/*** META ((export #t)) */

var sc_sin = Math.sin;

/*** META ((export #t)) */

var sc_cos = Math.cos;

/*** META ((export #t)) */

var sc_tan = Math.tan;

/*** META ((export #t)) */

var sc_asin = Math.asin;

/*** META ((export #t)) */

var sc_acos = Math.acos;

/*** META ((export #t)) */

var sc_atan = Math.atan;

/*** META ((export #t)) */

var sc_sqrt = Math.sqrt;

/*** META ((export #t)) */

var sc_expt = Math.pow;

// LIMITATION: we don't have complex numbers.

// LIMITATION: the following functions are hence not implemented.

// LIMITATION: make-rectangular, make-polar, real-part, imag-part, magnitude, angle

// LIMITATION: 2 argument atan

/*** META ((export #t)

           (peephole (id)))

*/

function sc_exact2inexact(x) {

    return x;

}

/*** META ((export #t)

           (peephole (id)))

*/

function sc_inexact2exact(x) {

    return x;

}

function sc_number2jsstring(x, radix) {

    if (radix)

	return x.toString(radix);

    else

	return x.toString();

}

function sc_jsstring2number(s, radix) {

    if (s === "") return false;

    if (radix) {

	var t = parseInt(s, radix);

	if (!t && t !== 0) return false;

	// verify that each char is in range. (parseInt ignores leading

	// white and trailing chars)

	var allowedChars = "01234567890abcdefghijklmnopqrstuvwxyz".substring(0, radix+1);

	if ((new RegExp("^["+allowedChars+"]*$", "i")).test(s))

	    return t;

	else return false;

    } else {

	var t = +s; // does not ignore trailing chars.

	if (!t && t !== 0) return false;

	// simply verify that first char is not whitespace.

	var c = s.charAt(0);

	// if +c is 0, but the char is not "0", then we have a whitespace.

	if (+c === 0 && c !== "0") return false;

	return t;

    }

}

/*** META ((export #t)

           (type bool)

           (peephole (not)))

*/

function sc_not(b) {

    return b === false;

}

/*** META ((export #t)

           (type bool))

*/

function sc_isBoolean(b) {

    return (b === true) || (b === false);

}