lappend results "n= $n\tCollisions= $col \t\t\tCurrent n_min= $n_min_col\tCurrent min_col=$min_col"
	}
	return [llength $results]
    }

}

proc wideimpure {x} {
    expr {wide($x)}
}

# A simple helper that is not compiled, but rather just shortens code below

proc cleanopt {script} {
    variable cleanopt
    set code [uplevel 1 [list catch $script cleanopt(msg) cleanopt(opt)]]
    set msg $cleanopt(msg)

    upvartest2::test2
    upvartest2::test3
    upvartest2::test4

    {hash::H9fast ultraantidisestablishmentarianistically}
    {hash::H9mid ultraantidisestablishmentarianistically}
    {hash::H9slow ultraantidisestablishmentarianistically}

    {wideimpure 3.0}
}
set demos'slow' {
    {flightawarebench::test 5 5 2}
    {llength [hash::main]}
}

#########################################################################

    upvar0
    upvar0a
    upvartest0::*
    upvartest1::*
    upvartest2::*
    flightawarebench::*
    hash::*
    wideimpure
}
set toCompile'slow' {
    parseBuiltinsTxt::main
}

#############################################################################
#

# generate-function-param-check --
#
#	Generates a check to make sure that a value conforms with a function's
#	requirement for its parameter type. Do not call from anywhere but
#	bytecode-to-quads!
#
# Parameters:
#	q - A list comprising the function name and arguments expressed as
#           quadcode values.
#
# Results:
#	None.
#
# Side effects:
#	Inserts a parameter type checking sequence.
#

	# 2
	my quads [list initParamTypeException $i] {temp @exception} \
	    $val $functionName
	# 3
	my quads extractFail {temp @exception} {temp @exception}
	# 4
	my generate-jump $target
	# 5 - ok:
        my quads [list purifyParam $i] $val $val $functionName
	# 6
	# (next instruction)
	
    }
}

# quads --
#

			lset bbcontent $b $j \
			    [list initException $result $msgLit $exn \
				 {literal 1} {literal 0}]
			incr j
		    } else {
			my removeUse $src $b
			my replaceUses $result Nothing
			# delete the quad
		    }

		}

		"instanceOfParamType" {
		    lassign $q op result src fref
		    set t [my determineFunctionParamType $op $fref]
		    if {$t != $quadcode::dataType::STRING} {
			set t [expr {$t | $quadcode::dataType::IMPURE}]
			set op [list "instanceOf" $t [nameOfType $t]]
			lset bbcontent $b $j [list $op $result $src]
			incr j
		    } else {
			my removeUse $src $b
			my replaceUses $result {literal 1}
			# delete the quad
		    }
		}

		"purifyParam" {
		    lassign $q op result src fref
		    set t [my determineFunctionParamType $op $fref]
		    if {$t != $quadcode::dataType::STRING} {
			lset bbcontent $b $j [list purify $result $src]
			incr j
		    } else {
			my removeUse $src $b
			my replaceUses $result $src
			# delete the quad
		    }
		}

		default {
		    lset bbcontent $b $j $q
		    incr j
		}

	}
	copy {
	    return [typeOfOperand $types [lindex $q 2]]
	}
	purify {
	    return [expr {[typeOfOperand $types [lindex $q 2]] & ~$IMPURE}]
	}
	purifyParam {
	    # Will be replaced with 'purify' when type is known, but must
	    # be at most a subset of the type of the source operand
	    return [typeOfOperand $types [lindex $q 2]]
	}
	unset {
	    return $NEXIST
	}
	setReturnCode {
	    return $FAIL
	}
	initException {

   1 or 0 according to the result.
{{instanceOfParamType N} TGT SRC CMD}
   Sets TGT to 1 or 0 depending on whether the type of SRC is appropriate
   as parameter #N to the command CMD
{{initParamTypeException N} TGT SRC CMD}
   Sets TGT to a FAIL value indicating that SRC is inappropriate for parameter
   #N to the command CMD.
{purify TGT SRC}
   Sets TGT to SRC, with any IMPURE indication removed
{{purifyParam N} TGT SRC FUNC}
   Sets TGT to SRC, with any IMPURE indication removed, if FUNC is a built-in
   math function requiring a pure value as argument #N.
   Otherwise, simply sets TGT to SRC. This operation is
   replaced with 'purify' or removed during optimization. It is there to
   purify the operands of built-in mathfuncs.

For these operations, the data types that must be implemented are INT32,
INT, ENTIER, DOUBLE; the same four data types unioned with EMPTY; and the
complements of these eight types, so there are sixteen variants in all.