{cf varname elem value ec {name ""}} \
	{
	    set result [my call ${tcl.direct.set} \
			    [list $varname $elem $value $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directUnset(CALLFRAME,STRING,INT) --
    #
    #	Unset a variable, which should be referred to by a fully-qualified
    #	name. NOTE: this operation can fail because of traces so it produces a
    #	ZEROONE FAIL (with meaningless value when not failing). Quadcode
    #	implementation ('directUnset').
    #
    # Parameters:
    #	cf -	Callframe in which non-fully-qualified names should resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	flag -	Whether failures are allowed, as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the unset was successful.

    method directUnset(CALLFRAME,STRING,INT) {cf varname flag ec {name ""}} {
	set result [my call ${tcl.direct.unset} \
			[list $varname {} $flag $ec] $name]
	return [my frame.pack $cf $result]
    }

    # Builder:directArrayUnset(CALLFRAME,STRING,STRING,INT) --
    #
    #	Unset an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a ZEROONE FAIL (with meaningless value when not
    #	failing). Quadcode implementation ('directArrayUnset').
    #
    # Parameters:
    #	cf -	Callframe in which non-fully-qualified names should resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	flag -	Whether failures are allowed, as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the unset was successful.

    method directArrayUnset(CALLFRAME,STRING,STRING,INT) \
	{cf varname elem flag ec {name ""}} {
	    set result [my call ${tcl.direct.unset} \
			    [list $varname $elem $flag $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directIsArray(STRING) --
    #
    #	Tests if the variable whose name we are given is an array. NOTE: this
    #	operation can fail because of traces so it produces a BOOL FAIL.
    #	Quadcode implementation ('directIsArray').
    #

		    set srcs [my ConvertIndices 0 strlen 1 2]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}

		"directIsArray" - "directMakeArray" -
		"regexp" - "listLength" -
		"listIn" - "listNotIn" - "dictIterStart" -
		"dictAppend" - "dictIncr" - "dictLappend" - "dictSize" -
		"div" - "expon" - "mod" - "verifyList" -
		"dictGetOrNexist" - "dictSetOrUnset" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}
		"directGet" - "directSet" -
		"directArrayGet" - "directArraySet" -
		"directAppend" - "directLappend" -
		"directLappendList" -
		"directArrayAppend" - "directArrayLappend" -
		"directArrayLappendList" -
		"directUnset" -	"directArrayUnset"
		{
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    set resNoCF [$b frame.value $res]

    #	Boolean that indicates whether we created the method with the
    #	requested signature.
    #
    # Side effects:
    # 	May create a method on the current object.

    method MakeTypecastWrapper {signature} {

	::puts "Make typecast wrapper for $signature"; ::flush stdout
	set tick [clock microseconds]

	# This method inserts conversions to lift, e.g., INT to DOUBLE as
	# necessary, provided there is a way of generating the instruction
	# with DOUBLE in the first place.

	# First, extract the type signature that we're trying to generate.
	if {![regexp {^([^()]+)\(([\w, ]+)\)$} $signature -> name types]} {

	    }
	    set n ${name}([join $types2 ,])
	    if {$n eq $signature} continue
	    if {$n in [info class methods [self class]]} {
		lappend mapped $thiscost $n $cvts
	    }
	}

	set tock [clock microseconds]
	set dur [format "%.6f" [expr {1.0e-6 * ($tock - $tick)}]]
	::puts "Identified [expr {[llength $mapped]/3}] typecast candidates in $dur s"
	::flush stdout

	# Select the cheapest conversion and generate the method that uses it.
	set num [llength $types]
	foreach {- n cvts} [lsort -stride 3 -integer -index 0 $mapped] {
	    set formals [lindex [info class definition [self class] $n] 0]
	    set body1 "set {string casts} {}"
	    set body2 ""

		my generate-callframe-op \
		    $pc directArraySet $var $var $elem $value
	    }
	    unsetStk {
		set flags [list literal [lindex $insn 1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc \
		    directUnset {temp opd0} $var $flags
	    }
	    unsetArrayStk {
		set flags [list literal [lindex $insn 1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc directArrayUnset \
		    {temp opd0} $var $elem $flags
	    }
	    dictGet {
		set idxNum [lindex $insn 1]
		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]

	}
	directGet - directSet - directArrayGet - directArraySet -
	directAppend - directLappend - directLappendList -
	directArrayAppend - directArrayLappend - directArrayLappendList {
	    # Can't assume more; these may be touching traced variables
	    return [expr {$CALLFRAME | $STRING | $FAIL}]
	}
	directUnset - directArrayUnset {
	    # may be touching traced variables, and may fail but does not
	    # return a direct result
	    return [expr {$CALLFRAME | $FAIL}]
	}
	directExists - directArrayExists {
	    return $BOOL
	}
	directIsArray - directMakeArray {
	    return [expr {$BOOL | $FAIL}]
	}
	procLeave {
	    # Produces a pure FAIL
	    return $FAIL
	}
	default {