set src1 [lindex $srcs 0]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set canFail [expr {"FAIL" in operandType($tgt)}]
		    set ec [if {$canFail} {list $errorCode}]
		    if {consumed($src1, $pc + 1)} {
			$b printref [lindex $srcs 0] "[lindex $l 0 0]:A:"
			set res [$b $opcode {*}$srcs {*}$ec $name]
		    } else {
			$b printref [lindex $srcs 0] "[lindex $l 0 0]:B:"
			$b addReference([my OperandType $src1]) [lindex $srcs 0]
			set res [$b $opcode {*}$srcs {*}$ec $name]
			$b dropReference([my OperandType $src1]) [lindex $srcs 0]
		    }
		    if {$canFail} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }

		    set srcs [lassign $l opcode tgt srcObj]
		    set name [my LocalVarName $tgt]
		    if {[llength $srcs] == 1} {
			# Simple case
			set srcs [list $srcObj {*}$srcs]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]
			set res [$b $opcode {*}$srcs $name]
			my StoreResult $tgt $res
		    } else {
			# Need to construct the variadic path
			set vectortypes [lmap s $srcs {my OperandType $s}]
			set vector [$b buildVector $objv $vectortypes \
				  [lmap s $srcs {my LoadOrLiteral $s}]]
			append opcode ( [my OperandType $srcObj] )

	    return [$b frame.pack $frame $value $name]
	} elseif {"CALLFRAME" in $tgttype} {
	    error "callframe injection"
	}

	# Handle FAIL-extended types
	if {"FAIL" eq $srctype && "FAIL" in $tgttype} {
	    my Warn "widen FAIL (%s) to %s" [PrintValueToString $value] $tgttype
	    # Implementation type of pure FAIL is int32 (Tcl result code)
	    set tgttype [lrange $tgttype 1 end]
	    return [$b fail $tgttype $value]
	} elseif {"FAIL" in $srctype && "FAIL" in $tgttype} {
	    set value [$b unmaybe $value]
	    set srctype [lrange $srctype 1 end]
	    set tgttype [lrange $tgttype 1 end]

	#
	# Increment the reference count of a Tcl_Obj reference if the
	# object is supplied

	set f [$m local "tcl.addFailReference" void<-Tcl_Obj*?]
	params value:maybeObjPtr
	build {
	    my condBr [my maybe $value] $incr $nothing
	label incr "action.required.afr"
	    set value [my unmaybe $value "objPtr"]
	    $api Tcl_IncrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	##### tcl.dropFailReference #####
	#
	# Type signature: objPtr:Tcl_Obj*? -> void
	#
	# Decrement the reference count of a Maybe containing a Tcl_Obj
	# reference, and delete it if the reference count drops to zero.

	set f [$m local "tcl.dropFailReference" void<-Tcl_Obj*?]
	params value:maybeObjPtr
	build {
	    my condBr [my maybe $value] $decr $nothing
	label decr "action.required"
	    set value [my unmaybe $value "objPtr"]
	    $api Tcl_DecrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	#
	# Decrement the reference count of a Maybe Maybe containing a Tcl_Obj
	# reference, and delete it if the reference count drops to zero.

	set f [$m local "tcl.dropFailNExistReference" void<-Tcl_Obj*!?]
	params value:maybeObjPtr
	build {
	    my condBr [my maybe $value] $decr $nothing
	label decr "action.required"
	    my Call tcl.dropNExistReference [my unmaybe $value]
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	params pr val prefix
	build {
	    my condBr [my maybe $val] $done $print
	label print:
	    my Call writeref $pr [my unmaybe $val] $prefix
	    my ret
	label done:
	    my Call writeref $pr {} $prefix
	    my ret
	}
	set f [$m local writearef void<-int,ARRAY,char* noinline]
	params pr val prefix
	build {
	    nonnull $val
	    set chan [$api Tcl_GetStdChannel [Const [expr 1<<3]]]

	    }
	    {NOTHING STRING} {
		append body2 { [my undef STRING]}
	    }
	    {{EXPANDED STRING} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED LIST} LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED DICT} DICT} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED INT} INT} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED DOUBLE} DOUBLE} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED NUMERIC} NUMERIC} {

	    # Simple numbers are simple words when not IMPURE
	    if {istype($t1,$NUMERIC) && !($t1 & $IMPURE)} {
		return $t1
	    }
	    return [expr {$EXPANDED | $t1}]
	}
	verifyList {
	    return [expr {$FAIL | $LIST}]
	}
	invoke {
	    # We know the result type of a handful of the things
	    # that might be invoked
	    if {[lindex $q 3 0] eq "literal"} {
		set rtype [my typeOfInvoke [lindex $q 3 1] [lrange $q 4 end]]
	    } else {

	}
	listAppend - listConcat {
	    return $LIST
	}
	listIndex {
	    if {[llength $q] == 4} {
		set t2 [typeOfOperand $types [lindex $q 3]]
		# TODO: have end-relative indices be their own type
		if {istype($t2, $INT) || istype($t2, $ZEROONE)} {
		    return $STRING
		}
	    } elseif {[llength $q] == 3} {
		return [typeOfOperand $types [lindex $q 2]]
	    }
	    return [expr {$STRING | $FAIL}]
	}
	listRange {
	    set t1 [typeOfOperand $types [lindex $q 3]]
	    set t2 [typeOfOperand $types [lindex $q 4]]
	    # TODO: have end-relative indices be their own type
	    if {(istype($t1, $INT) || istype($t1, $ZEROONE)) &&
		    (istype($t2, $INT) || istype($t2, $ZEROONE))} {
		return $LIST
	    }
	    return [expr {$LIST | $FAIL}]
	}
	listSet {
	    return [expr {$LIST | $FAIL}]
	}
	strindex - strrange - strreplace - dictGet {
	    # TODO: have end-relative indices be their own type and be non-failing
	    return [expr {$STRING | $FAIL}]
	}
	dictSetOrUnset - dictAppend {
	    return $DICT
	}
	dictUnset {
	    if {[llength $q] == 4} {