#	The concatenated value as an LLVM value reference.

    method concat() {vector {name ""}} {
	my ExtractVector $vector
	my call ${tcl.concatenate} [list $len $ary] $name
    }

    # Builder:dictAppend(STRING,STRING,STRING) --
    #
    #	Append a value to a key in a dictionary. NOTE: this operation can fail
    #	(e.g., because it can be given an invalid dictionary) so it produces a
    #	STRING FAIL. Quadcode implementation ('dictAppend').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value to append 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:
    #	The resulting dictionary as an LLVM value reference, or a FAIL.

    method dictAppend(STRING,STRING,STRING) {dict key value ec {name ""}} {
	my call ${tcl.dict.append} [list $dict $key $value $ec] $name
    }

    # Builder:dictExists(STRING) --
    #
    #	Find whether a key exists in a dictionary. This version uses a vector
    #	of values for the key path. Quadcode implementation ('dictExists').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the value exists as an LLVM ZEROONE value reference.

    method dictExists(STRING) {dict vector {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.exists} [list $dict $len $ary] $name
    }




    # Builder:dictExists(STRING,STRING) --
    #
    #	Find whether a key exists in a dictionary. This version uses a single
    #	simple key. Quadcode implementation ('dictExists').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the value exists as an LLVM ZEROONE value reference.

    method dictExists(STRING,STRING) {dict key {name ""}} {
	my call ${tcl.dict.exists1} [list $dict $key] $name
    }




    # Builder:dictGet(STRING) --
    #
    #	Retrieve a value from a dictionary. This version uses a vector as a
    #	key path. NOTE: this operation can fail (e.g., because it can be given
    #	an invalid dictionary) so it produces a STRING FAIL. Quadcode
    #	implementation ('dictGet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The retrieved value as an LLVM value reference, or a FAIL.

    method dictGet(STRING) {dict vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.get} [list $dict $len $ary $ec] $name
    }

    # Builder:dictGet(STRING,STRING) --
    #
    #	Retrieve a value from a dictionary. This version uses a single simple
    #	key. NOTE: this operation can fail (e.g., because it can be given an
    #	invalid dictionary) so it produces a STRING FAIL. Quadcode
    #	implementation ('dictGet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key 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:
    #	The retrieved value as an LLVM value reference, or a FAIL.

    method dictGet(STRING,STRING) {dict key ec {name ""}} {
	my call ${tcl.dict.get1} [list $dict $key $ec] $name
    }

    # Builder:dictGetOrNexist(STRING,STRING) --
    #
    #	Retrieve a value from a dictionary, or NEXIST if the key doesn't map
    #	to a value in the dict. This version uses a single simple key. NOTE:
    #	this operation can fail (e.g., because it can be given an invalid
    #	dictionary) so it produces a FAIL NEXIST STRING. Quadcode
    #	implementation ('dictGetOrNexist').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key 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:
    #	The retrieved value as an LLVM value reference, or a NEXIST or FAIL.




    method dictGetOrNexist(STRING,STRING) {dict key ec {name ""}} {

	my call ${tcl.dict.get1.empty} [list $dict $key $ec] $name
    }

    # Builder:dictIncr(STRING,STRING,INT) --
    #
    #	Increment the value for a key in a dictionary. NOTE: this operation
    #	can fail (e.g., because it can be given an invalid dictionary) so it
    #	produces a STRING FAIL. Quadcode implementation ('dictIncr').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The amount to increment by 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:
    #	The resulting dictionary as an LLVM value reference, or a FAIL.

    method dictIncr(STRING,STRING,INT) {dict key value ec {name ""}} {
	my call ${tcl.dict.incr} [list $dict $key $value $ec] $name
    }

    # Builder:dictIterStart(STRING) --
    #
    #	Start iterating over a dictionary; other opcodes are used to retrieve
    #	what the state of the iteration is. NOTE: this operation can fail
    #	(e.g., because it can be given an invalid dictionary) so it produces a
    #	DICTITER FAIL. Quadcode implementation ('dictIterStart').
    #
    # Parameters:
    #	dict -	The dictionary 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:
    #	The iteration state as an LLVM DICTITER value reference, or a FAIL.

    method dictIterStart(STRING) {dict ec {name ""}} {
	my call ${tcl.dict.iterStart} [list $dict $ec] $name
    }

    # Builder:dictIterNext --
    #
    #	Get the next step when iterating over a dictionary; other opcodes are
    #	used to retrieve what the state of the iteration is. Quadcode
    #	implementation ('dictIterNext').

    # Results:
    #	The termination flag as an LLVM ZEROONE value reference.

    method dictIterDone {iter {name ""}} {
	my call ${tcl.dict.iterDone} [list $iter] $name
    }

    # Builder:dictLappend(STRING,STRING,STRING) --
    #
    #	List-append a value to a key in a dictionary. NOTE: this operation can
    #	fail (e.g., because it can be given an invalid dictionary) so it
    #	produces a STRING FAIL. Quadcode implementation ('dictLappend').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value to append 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:
    #	The resulting dictionary as an LLVM value reference, or a FAIL.

    method dictLappend(STRING,STRING,STRING) {dict key value ec {name ""}} {
	my call ${tcl.dict.lappend} [list $dict $key $value $ec] $name
    }

    # Builder:dictSet(STRING,STRING) --
    #
    #	Set or create a value in a dictionary. This version uses a vector as a
    #	dictionary key path. NOTE: this operation can fail (e.g., because it
    #	can be given an invalid dictionary) so it produces a STRING FAIL.
    #	Quadcode implementation ('dictSet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	value -	The value as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictSet(STRING,STRING) {dict value vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.set} [list $dict $len $ary $value $ec] $name
    }

    # Builder:dictSet(STRING,STRING,STRING) --
    #
    #	Set or create a value in a dictionary. This version uses a single











    #	simple key. NOTE: this operation can fail (e.g., because it can be



    #	given an invalid dictionary) so it produces a STRING FAIL. Quadcode



    #	implementation ('dictSet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.




















    #	value -	The value 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:
    #	The new dictionary value.

    method dictSet(STRING,STRING,STRING) {dict key value ec {name ""}} {
	my call ${tcl.dict.set1} [list $dict $key $value $ec] $name
    }

    # Builder:dictSetOrUnset(STRING,STRING,NEXIST) --
    #
    #	Remove a value in a dictionary. This version uses a single simple key.
    #	NOTE: this operation can fail (e.g., because it can be given an
    #	invalid dictionary) so it produces a STRING FAIL. Quadcode
    #	implementation ('dictSetOrUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The NEXIST value (actually ignored).
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value, or FAIL.

    method dictSetOrUnset(STRING,STRING,NEXIST) {dict key value ec {name ""}} {
	my call ${tcl.dict.set1.empty} [list $dict $key [my nothing STRING] $ec] $name
    }

    # Builder:dictSetOrUnset(STRING,STRING,NEXIST STRING) --
    #
    #	Set, create or remove a value in a dictionary. This version uses a
    #	single simple key, and the value can be NEXIST to remove the key.
    #	NOTE: this operation can fail (e.g., because it can be given an
    #	invalid dictionary) so it produces a STRING FAIL. Quadcode
    #	implementation ('dictSetOrUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value as an LLVM value reference, or NEXIST.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value, or FAIL.

    method dictSetOrUnset(STRING,STRING,NEXIST\040STRING) {dict key value ec {name ""}} {
	my call ${tcl.dict.set1.empty} [list $dict $key $value $ec] $name
    }

    # Builder:dictSetOrUnset(STRING,STRING,NEXIST STRING) --
    #
    #	Set or create a value in a dictionary. This version uses a single
    #	simple key.  NOTE: this operation can fail (e.g., because it can be
    #	given an invalid dictionary) so it produces a STRING FAIL. Quadcode
    #	implementation ('dictSetOrUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value 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:
    #	The new dictionary value, or FAIL.

    method dictSetOrUnset(STRING,STRING,STRING) {dict key value ec {name ""}} {
	my call ${tcl.dict.set1.empty} [list $dict $key [my just $value] $ec] $name
    }

    # Builder:dictSize(STRING) --
    #
    #	Get the size of a dictionary, i.e., the number of key-value pairs.
    #
    # Parameters:
    #	value -	The STRING LLVM value reference to a dict to get the size of.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	An INT FAIL in an LLVM value reference.

    method dictSize(STRING) {value ecvar {name ""}} {
	my call ${tcl.dict.size} [list $value $ecvar] $name
    }




    # Builder:dictUnset(STRING) --
    #
    #	Remove a key from a dictionary. This version uses a vector as a
    #	dictionary key path. NOTE: this operation can fail (e.g., because it
    #	can be given an invalid dictionary) so it produces a STRING FAIL.
    #	Quadcode implementation ('dictUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictUnset(STRING) {dict vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.unset} [list $dict $len $ary $ec] $name
    }

    # Builder:dictUnset(STRING,STRING) --
    #
    #	Remove a key from a dictionary. This version uses a single simple
    #	key. NOTE: this operation can fail (e.g., because it can be given an
    #	invalid dictionary) so it produces a STRING FAIL. Quadcode
    #	implementation ('dictUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key 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:
    #	The new dictionary value.

    method dictUnset(STRING,STRING) {dict key ec {name ""}} {
	my call ${tcl.dict.unset1} [list $dict $key $ec] $name
    }

    # Builder:directAppend(STRING,STRING) --
    #
    #	Append a value to a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation

    #	None.

    method dropReference {value} {
	my Call tcl.dropReference $value
	return
    }

    # Builder:dropReference(IMPURE EMPTY DICT) --
    #
    #	Generate code to decrement the reference count of a value and delete
    #	the value if it has ceased to be used.
    #
    # Parameters:
    #	value -	The IMPURE EMPTY DICT LLVM value reference for the operand.
    #
    # Results:
    #	None.

    method dropReference(IMPURE\040EMPTY\040DICT) {value} {
	my Call tcl.dropReference $value
	return
    }

    # Builder:dropReference(IMPURE EMPTY LIST) --
    #
    #	Generate code to decrement the reference count of a value and delete
    #	the value if it has ceased to be used.
    #
    # Parameters:
    #	value -	The IMPURE EMPTY LIST LLVM value reference for the operand.
    #
    # Results:
    #	None.

    method dropReference(IMPURE\040EMPTY\040LIST) {value} {
	my Call tcl.dropReference $value
	return
    }

    # Builder:dropReference(STRING) --
    #
    #	Generate code to decrement the reference count of a value and delete

	    }
	} else {
	    set len [Const 0]
	}
	my call ${tcl.list.create} [list $len [my gep $objv 0 0]] $name
    }

    # Builder:listAppend(STRING,STRING) --
    #
    #	Append an element to a list. NOTE: this operation can fail (e.g.,
    #	because it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listAppend').
    #
    # Parameters:
    #	list -	List value to get append to, in an LLVM STRING reference.
    #	value -	The value to append as an LLVM STRING value reference.







































































    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.









    method listAppend(STRING,STRING) {list value ec {name ""}} {














	my call ${tcl.list.append} [list $list $value $ec] $name
    }




    # Builder:listConcat(STRING,STRING) --
    #
    #	Append a list of elements to a list. NOTE: this operation can fail
    #	(e.g., because it can be given an invalid list) so it produces a
    #	STRING FAIL. Quadcode implementation ('listConcat').
    #
    # Parameters:
    #	list -	List value to get append to, in an LLVM STRING reference.
    #	value -	The list of values to append, as an LLVM STRING value
    #		reference.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.

    method listConcat(STRING,STRING) {list value ec {name ""}} {
	my call ${tcl.list.concat} [list $list $value $ec] $name
    }

    # Builder:listIn(STRING,STRING) --
    #
    #	Determine if an element is present in a list by simple linear search.
    #	NOTE: this operation can fail (e.g., because it can be given an
    #	invalid list) so it produces an INT FAIL. Quadcode implementation
    #	('listIn').
    #
    # Parameters:
    #	value -	The value to check for, as an LLVM STRING value reference.
    #	list -	List value to search, in an LLVM STRING reference.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	If the element is present, as an LLVM INT FAIL reference.

    method listIn(STRING,STRING) {value list ec {name ""}} {
	my call ${tcl.list.in} [list $value $list $ec] $name
    }

    # Builder:listIndex(STRING) --
    #
    #	Get an element of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listIndex').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM STRING reference.
    #	vector -
    #		The indices as an LLVM vector value reference.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.

    method listIndex(STRING) {value vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.list.index} [list $value $len $ary $ec] $name
    }

    # Builder:listIndex(STRING,INT) --
    #
    #	Get an element of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listIndex').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM STRING reference.
    #	index -	Index value to use, in an LLVM INT reference.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.

    method listIndex(STRING,INT) {value index ec {name ""}} {
	my call ${tcl.list.index1} [list $value $index $ec] $name
    }

    # Builder:listIndex(STRING,STRING) --
    #
    #	Get an element of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listIndex').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM STRING reference.
    #	index -	Index value to use, in an LLVM STRING reference.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.

    method listIndex(STRING,STRING) {value index ec {name ""}} {
	my call ${tcl.list.indexList} [list $value $index $ec] $name
    }

    # Builder:listLength(STRING) --
    #
    #	Get the length of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces an INT FAIL. Quadcode
    #	implementation ('listLength').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM STRING reference.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The length of the list, as an LLVM INT FAIL reference.

    method listLength(STRING) {value ec {name ""}} {
	my call ${tcl.list.length} [list $value $ec] $name
    }




    # Builder:listRange(STRING,INT,INT) --























    #
    #	Get a sublist of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listRange').
    #
    # Parameters:
    #	value -	List value to get a substring of, in an LLVM STRING reference.
    #	from -	Index of first element to return, in an LLVM INT reference.
    #	to -	Index of last element to return, in an LLVM INT reference.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The sublist, as an LLVM STRING FAIL reference.

    method listRange(STRING,INT,INT) {value from to ec {name ""}} {
	my call ${tcl.list.range1} [list $value $from $to $ec] $name
    }

    # Builder:listRange(STRING,STRING,STRING) --
    #
    #	Get a sublist of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listRange').
    #
    # Parameters:
    #	value -	List value to get a substring of, in an LLVM STRING reference.
    #	from -	Index of first element to return, in an LLVM STRING reference.
    #	to -	Index of last element to return, in an LLVM STRING reference.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The sublist, as an LLVM STRING FAIL reference.

    method listRange(STRING,STRING,STRING) {value from to ec {name ""}} {



	my call ${tcl.list.range} [list $value $from $to $ec] $name
    }

    # Builder:listSet(STRING,STRING) --
    #
    #	Update an element in a sublist of a list. NOTE: this operation can
    #	fail (e.g., because it can be given an invalid list) so it produces a
    #	STRING FAIL. Quadcode implementation ('listSet').
    #
    # Parameters:
    #	list -	List value to get a substring of, in an LLVM STRING reference.
    #	elem -	The value to write into the list, in an LLVM STRING reference.
    #	vector -
    #		The indices as an LLVM vector value reference.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The updated list, as an LLVM STRING FAIL reference.

    method listSet(STRING,STRING) {list elem vector ecvar {name ""}} {




	my ExtractVector $vector
	my call ${tcl.list.set} [list $list $len $ary $elem $ecvar] $name
    }

    # Builder:listSet(STRING,INT,STRING) --
    #
    #	Update an element of a list. NOTE: this operation can fail (e.g.,
    #	because it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listSet').
    #
    # Parameters:
    #	list -	List value update, in an LLVM STRING reference.
    #	idx -	The index into the list to set, in an LLVM INT reference.
    #	elem -	The value to write into the list, in an LLVM STRING reference.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The updated list, as an LLVM STRING FAIL reference.

    method listSet(STRING,INT,STRING) {list idx elem ecvar {name ""}} {



	my call ${tcl.list.set1} [list $list $idx $elem $ecvar] $name
    }

    # Builder:listSet(STRING,STRING,STRING) --
    #
    #	Update an element of a list or sublist. NOTE: this operation can fail
    #	(e.g., because it can be given an invalid list) so it produces a
    #	STRING FAIL. Quadcode implementation ('listSet').
    #
    # Parameters:
    #	list -	List value update, in an LLVM STRING reference.
    #	idx -	The index into the list to set, in an LLVM STRING reference.
    #	elem -	The value to write into the list, in an LLVM STRING reference.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The updated list, as an LLVM STRING FAIL reference.

    method listSet(STRING,STRING,STRING) {list idx elem ecvar {name ""}} {



	my call ${tcl.list.setList} [list $list $idx $elem $ecvar] $name
    }

    # Builder:lor(INT,INT) --
    #
    #	Generate code to compute the logical or of two INTs.  Quadcode
    #	implementation ('lor').

	if {[string match "* NEXIST" $type]} {
	    set type [string range $type 0 end-7]
	} elseif {[string match "NEXIST *" $type]} {
	    set type [string range $type 7 end]
	}
	my insert [my undef $type!] [Const true bool] 0 $name
    }





























    # Builder:narrowToType.LIST(STRING) --
    #
    #	Generate code to parse the given STRING and extract a LIST. The
    #	STRING is already be known to contain a value of the right type (due
    #	to higher-level quadcode constraints). Quadcode implementation
    #	('narrowToType').
    #
    # Parameters:
    #	value -	The STRING LLVM value reference to parse.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A DOUBLE LLVM value reference.

    method narrowToType.LIST(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.IMPURE_LIST(STRING) {value {name ""}} {
	return $value
    }

		"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
		}
		"listAppend" - "listConcat" - "listRange" {
		    set srcs [lassign $l opcode tgt]
		    set src1 [lindex $srcs 0]
		    set name [my LocalVarName $tgt]

			my StoreResult $tgt $res
			$b clearVector $vector
		    }
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		}
		"dictSet" - "listSet" {
























		    set srcs [lassign $l opcode tgt srcObj srcValue]
		    set name [my LocalVarName $tgt]
		    if {[llength $srcs] == 1} {
			# Simple case
			set srcs [list $srcObj {*}$srcs $srcValue]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]

		    set t [lrange $tgttype 1 end]
		    set value [$b fail $t "" $name]
		}
		"NEXIST *" {
		    set t [lrange $tgttype 1 end]
		    set value [$b nothing $t $name]
		}
		"STRING" - "EMPTY" {
		    set value [my LoadOrLiteral "literal {}"]
		}
		default {
		    # Should be unreachable in practice
		    my Warn "widened void to %s; result is undef" $tgttype
		    set value [$b undef $tgttype]
		}

		set value [$b packNumericDouble $value $name]
	    } else {
		set value [$b packNumericInt $value $name]
	    }
	} elseif {$srctype eq "EMPTY" && $tgttype eq "STRING"} {
	    set value [Const "" STRING]
	} elseif {$srctype ne $tgttype} {



	    my Warn "unimplemented convert from '%s' to '%s'" $srctype $tgttype

	}
	if {[Type $tgttype] eq [Type [TypeOf $value]?]} {
	    set value [$b ok $value]
	} elseif {[Type $tgttype] eq [Type [TypeOf $value]!]} {
	    set value [$b just $value]
	}
	return $value

    variable tcl.dict.get1 tcl.dict.get tcl.dict.set1 tcl.dict.set
    variable tcl.dict.exists1 tcl.dict.exists tcl.dict.unset1 tcl.dict.unset
    variable tcl.dict.iterStart tcl.dict.iterNext tcl.dict.iterDone
    variable tcl.dict.iterKey tcl.dict.iterValue tcl.dict.addIterReference
    variable tcl.dict.addIterFailReference
    variable tcl.dict.dropIterReference tcl.dict.dropIterFailReference
    variable tcl.dict.append tcl.dict.lappend tcl.dict.incr tcl.dict.size
    variable tcl.dict.get1.empty tcl.dict.set1.empty
    variable tcl.maptoint

    # Variables holding implementations of Tcl's exception-handling machinery
    variable tcl.getresult tcl.getreturnopts tcl.initExceptionOptions
    variable tcl.initExceptionSimple tcl.processReturn tcl.procedure.return
    variable tcl.setErrorLine tcl.existsOrError tcl.logCommandInfo
    variable tcl.handleExceptionResult tcl.invoke.command tcl.invoke.expanded

	    my assume [my eq $before $after]
	    my ret $result
	}

	##### Function tcl.isPureByteArray #####
	##### Closure Build:isByteArray #####
	#
	# Type signature: objPtr:STRING -> int1
	#
	# Test if a STRING is actually a true byte array, that it can be
	# processed as bytes and not as unicode characters.

	set f [$m local "tcl.isPureByteArray" int1<-STRING readonly]
	params objPtr
	build {
	    nonnull $objPtr
	    set baType [$api tclByteArrayType]
	    set typePtr [my dereference $objPtr 0 Tcl_Obj.typePtr]
	    my condBr [my eq $baType $typePtr] $puretest $notBA
	label puretest:

	my closure isByteArray {STRING {name ""}} {
	    my call ${tcl.isPureByteArray} [list $STRING] $name
	}

	##### Function tcl.isUnicodeString #####
	##### Closure Build:isUnicodeString #####
	#
	# Type signature: objPtr:STRING -> int1
	#
	# Test if a STRING is stored internally as a sequence of Tcl_UniChar
	# (instead of as a sequence of Unicode characters encoded as UTF-8).

	set f [$m local "tcl.isUnicodeString" int1<-STRING readonly]
	params objPtr
	build {
	    nonnull $objPtr
	    set strType [$api tclStringType]
	    set type [my dereference $objPtr 0 Tcl_Obj.typePtr]
	    my ret [my eq $type $strType]
	}
	my closure isUnicodeString {STRING {name ""}} {
	    my call ${tcl.isUnicodeString} [list $STRING] $name
	}

	##### Function tcl.impl.getBoolean #####
	##### MAPPED CALL TO METHOD: Build:GetBoolean #####
	#
	# Type signature: valueObj:STRING -> int1*int1

	set f [$m local "tcl.impl.getBoolean" struct{int1,int1}<-STRING]
	params valueObj
	build {
	    nonnull $valueObj
	    set boolVar [my alloc int32 "boolPtr"]
	    set str [$api Tcl_GetString $valueObj]
	    set code [$api Tcl_GetBooleanFromObj {} $valueObj $boolVar]
	    set res [my undef struct{int1,int1}]
	    set res [my insert $res [my eq $code [Const 0]] 0]
	    set res \
		[my insert $res [my neq [my load $boolVar "bool"] [Const 0]] 1]
	    my ret $res
	}
	my closure GetBoolean {valueObj} {
	    my call ${tcl.impl.getBoolean} [list $valueObj] "result"
	}
	unset -nocomplain valueObj
	

	##### Function tcl.impl.getDouble #####
	##### MAPPED CALL TO METHOD: Build:GetDouble #####
	#
	# Type signature: valueObj:STRING -> int * int8[]
	#
	# Gets the (pseudo-)UTF-8 version of a string. Wrapper around Tcl API
	# to ensure that scope lifetime gets better understood.

	set f [$m local "tcl.impl.getDouble" struct{int1,double}<-STRING]
	my closure GetDouble {valueObj} {
	    my call ${tcl.impl.getDouble} [list $valueObj] "result"
	}
	params valueObj
	build {
	    nonnull $valueObj
	    set dblVar [my alloc double "dblPtr"]
	    set code [$api Tcl_GetDoubleFromObj {} $valueObj $dblVar]
	    set res [my undef struct{int1,double}]
	    set res [my insert $res [my eq $code [Const 0]] 0]
	    set res [my insert $res [my load $dblVar "dbl"] 1]
	    my ret $res
	}
	unset -nocomplain valueObj

	##### Function tcl.impl.getWide #####
	##### MAPPED CALL TO METHOD: Build:GetWide #####
	#
	# Type signature: valueObj:STRING -> bool * int64
	#
	# Gets an int64 from a Tcl string. Wrapper around Tcl API to ensure
	# that scope lifetime gets better understood.

	set f [$m local "tcl.impl.getWide" struct{int1,int64}<-STRING]
	my closure GetWide {valueObj {name "result"}} {
	    my call ${tcl.impl.getWide} [list $valueObj] $name
	}
	params valueObj
	build {
	    nonnull $valueObj
	    set intVar [my alloc int64 "intPtr"]

	    set p5 [my phi [list $p2 $p4] [list $nextOuter $fixP] "p.5"]
	    my ret [my sub $numBytes1 [my cast(int) [my diff $p5 $bytes]]]
	}

	##### Function tcl.impl.isAscii #####
	# Replacement for non-exposed UniCharIsAscii
	#
	# Type signature: ch:int16 -> int1
	#
	# Part of quadcode implementation ('strclass')
	#
	# Returns whether the character 'ch' is in the ASCII range.

	set f [$m local "tcl.impl.isAscii" bool<-int16 readnone]
	params ch
	build {
	    my ret [my and [my ge $ch [Const 0 int16]] \
			[my lt $ch [Const 0x80 int16]]]
	}

	##### Function tcl.impl.isXdigit #####
	# Replacement for non-exposed UniCharIsXdigit
	#
	# Type signature: ch:int16 -> int1
	#
	# Part of quadcode implementation ('strclass')
	#
	# Returns whether the character 'ch' is a hex digit.

	set f [$m local "tcl.impl.isXdigit" bool<-int16 readnone]
	params ch

	    my ret [Const true bool]
	label not:
	    my ret [Const false bool]
	}

	##### Function tcl.strclass #####
	#
	# Type signature: objPtr:STRING * class:int32 -> ZEROONE
	#
	# Quadcode implementation ('strclass')
	#
	# Returns whether all the characters in the string 'objPtr' are in the
	# character class given by 'class' (enumeration encoded as int32).

	set f [$m local "tcl.strclass" ZEROONE<-STRING,int]
	params objPtr class
	build {
	    nonnull $objPtr
	    lassign [my GetUnicode $objPtr obj] length string
	    my condBr [my gt $length $0] $test $match
	label test:
	    set end [my getelementptr $string [list $length]]

	    my ret [Const false bool]
	}

	##### Function tcl.impl.getIndex #####
	##### Closure Build:GetIndex #####
	#
	# Type signature: interp:Interp* * objPtr:Tcl_Obj* * end:int
	#			-> int1 * int
	#
	# Converts an index string into an offset into something (i.e., a
	# string or list). Returns a tuple of whether the conversion succeeded
	# (a boolean) and the index.

	set f [$m local "tcl.impl.getIndex" \
		   struct{bool,int}<-Interp*,Tcl_Obj*,int readonly]

	# Type signatures: obj:STRING -> {STRING,bool}
	#		   objdupe:{STRING,bool} -> void
	#
	# Helpers for the dictionary updating functions that reduce the amount
	# of explicit branch management in the code by factoring out common
	# patterns of reference handling.

	set f [$m local "obj.dedup" struct{STRING,int1}<-STRING]
	params obj
	build {
	    set duped [my shared $obj]
	    SetValueName $duped "duped"
	    set res [my insert [my undef struct{STRING,int1}] $duped 1]
	    my condBr $duped $duplicated $unshared
	label duplicated:
	    set dupe [$api Tcl_DuplicateObj $obj]
	    SetValueName $dupe "duplicateObj"
	    my ret [my insert $res $dupe 0]
	label unshared:
	    my ret [my insert $res $obj 0]
	}
	my closure Dedup {varName} {
	    upvar 1 $varName var
	    set token [my Call obj.dedup $var]
	    set var [my extract $token 0 [GetValueName $var]]
	    return $token
	}

	set f [$m local "obj.cleanup" void<-struct{STRING,int1}]
	params objdupe
	build {
	    my condBr [my extract $objdupe 1] $duplicated $unshared
	label duplicated:
	    my dropReference [my extract $objdupe 0]
	    my ret
	label unshared:

	    my ret $new
	label fail:
	    my ret [my null STRING]
	}

	##### Function tcl.isList #####
	#
	# Type signature: objPtr:STRING -> int1
	#
	# Part of quadcode implementation ('isInstance')
	#
	# Wrapper around Tcl_ListObjLength that uses it to do a list-ness
	# check.

	set f [$m local "tcl.isList" int1<-STRING]
	params objPtr
	build {
	    nonnull $objPtr
	    set var [my alloc int "length"]
	    set code [$api Tcl_ListObjLength {} $objPtr $var]
	    my ret [my eq $code $0]
	}

	##### Function tcl.list.create #####
	#
	# Type signature: objc:int * objv:STRING* -> STRING
	#
	# Core of quadcode implementation ('list')
	#
	# Wrapper around Tcl_NewListObj that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.create" STRING<-int,STRING*]
	params objc objv
	build {
	    nonnull $objv
	    set val [$api Tcl_NewListObj $objc $objv]
	    my addReference(STRING) $val
	    my ret $val
	}

	##### Function tcl.list.length #####
	#
	# Type signature: list:STRING * ecvar:int* -> INT?
	#
	# Core of quadcode implementation ('listLength')
	#
	# Wrapper around Tcl_ListObjLength that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.length" INT?<-STRING,int*]
	params list ecvar
	build {
	    noalias $list $ecvar
	    nonnull $list $ecvar
	    set var [my alloc int "length"]
	    set interp [$api tclInterp]
	    set code [$api Tcl_ListObjLength $interp $list $var]
	    my condBr [my eq $code $0] $ok $fail
	label ok:
	    my ret [my ok [my packInt32 [my load $var]]]
	label fail:
	    my store $1 $ecvar
	    my ret [my fail INT]
	}

	##### Function tcl.list.verify #####
	#
	# Type signature: value:STRING * ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('verifyList')
	#
	# Wrapper around a list operation (Tcl_ListObjLength) that verifies
	# that the value it is dealing with is a list; converting it to a FAIL
	# if it is not.

	set f [$m local "tcl.list.verify" STRING?<-STRING,int*]
	params value ecvar
	build {
	    noalias $value $ecvar
	    nonnull $value $ecvar
	    set var [my alloc int "length"]
	    set interp [$api tclInterp]
	    set code [$api Tcl_ListObjLength $interp $value $var]
	    my condBr [my eq $code $0] $ok $fail
	label ok:
	    $api Tcl_IncrRefCount $value
	    my ret [my ok $value]
	label fail:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.append #####
	#
	# Type signature: list:STRING * value:STRING * ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('listAppend')
	#
	# Wrapper around Tcl_ListObjLength that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.append" STRING?<-STRING,STRING,int*]
	params list value ecvar
	build {
	    noalias $ecvar
	    nonnull $list $value $ecvar
	    set interp [$api tclInterp]
	    my condBr [my shared $list] $sharedDupe $unshared
	label sharedDupe "shared.duplicate"
	    set copy [my ListDupe $interp $list "copy"]
	    my condBr [my nonnull $copy] $shared $error
	label shared:
	    $api Tcl_ListObjAppendElement {} $copy $value
	    my br $return
	label unshared:
	    set code [$api Tcl_ListObjAppendElement $interp $list $value]
	    my condBr [my eq $code $0] $return $error
	label return:
	    set list [my phi [list $copy $list] [list $shared $unshared] "list"]
	    $api TclInvalidateStringRep $list
	    my addReference(STRING) $list
	    my condBr [my shared $value] $exit $extraRef
	label extraRef "add.extra.reference.to.value"
	    my addReference(STRING) $value
	    my br $exit
	label exit:
	    my ret [my ok $list]
	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.concat #####
	#
	# Type signature: list:STRING * value:STRING * ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('listConcat')
	#
	# Wrapper around Tcl_ListObjLength that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.concat" STRING?<-STRING,STRING,int*]
	params list value ecvar
	build {
	    noalias $ecvar
	    nonnull $list $value $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set interp [$api tclInterp]
	    set code [$api Tcl_ListObjLength $interp $list $objc]
	    my condBr [my eq $code $0] $checkValue $error
	label checkValue "check.value.for.listness"
	    set len [my load $objc "len"]
	    set code [$api Tcl_ListObjGetElements $interp $value $objc $objv]
	    my condBr [my eq $code $0] $checkDupe $error
	label checkDupe "check.whether.to.duplicate"
	    my condBr [my shared $list] $dupe $concat
	label dupe "duplicate"
	    set copy [my ListDupe {} $list "copy"]
	    my br $concat
	label concat:
	    set working [my phi [list $list $copy] [list $checkDupe $dupe] "list"]
	    set objc [my load $objc "objc"]
	    set objv [my load $objv "objv"]
	    $api Tcl_ListObjReplace {} $working $len $0 $objc $objv
	    my addReference(STRING) $working
	    my ret [my ok $working]
	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.index #####
	#
	# Type signature: list:STRING * idxc:int * idxv:STRING* * ecvar:int*
	#			-> STRING?
	#
	# Core of quadcode implementation ('listIndex')
	#
	# Effectively an implementation of TclLindexFlat.

	set f [$m local "tcl.list.index" STRING?<-STRING,int,STRING*,int*]
	params list idxc idxv ecvar
	build {
	    noalias $list $idxv $ecvar
	    nonnull $list $idxv $ecvar
	    set iPtr [my alloc int "&i"]
	    set listPtr [my alloc STRING "&list"]
	    set listLenPtr [my alloc int "&listLen"]

	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.index1 #####
	#
	# Type signature: list:STRING * index:INT * ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('listIndex')
	#
	# Basic list indexing in the case where we know that the index is an
	# integer, which avoids many of the failure modes.

	set f [$m local "tcl.list.index1" STRING?<-STRING,INT,int*]
	params list index ecvar
	build {
	    noalias $list $ecvar
	    nonnull $list $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set interp [$api tclInterp]
	    set idx [my getInt32 $index]
	    set code [$api Tcl_ListObjGetElements $interp $list $objc $objv]
	    my condBr [my eq $code $0] $ok $fail
	label ok:
	    my condBr [my and [my ge $idx $0] [my lt $idx [my load $objc]]] \
		$realIndex $outOfBounds
	label realIndex "real.index"
	    set objv [my load $objv "objv"]
	    set obj [my load [my getelementptr $objv [list $idx]] "objPtr"]
	    my addReference(STRING) $obj
	    my ret [my ok $obj]
	label outOfBounds "out.of.bounds"
	    set obj [$api Tcl_NewObj]
	    my addReference(STRING) $obj
	    my ret [my ok $obj]
	label fail:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.indexList #####
	#
	# Type signature: list:STRING * index:STRING * ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('listIndex')
	#
	# Effectively an implementation of TclLindexList.

	set f [$m local "tcl.list.indexList" STRING?<-STRING,STRING,int*]
	params list index ecvar
	build {
	    noalias $ecvar
	    nonnull $list $index $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set interp [$api tclInterp]
	    set code [$api Tcl_ListObjGetElements $interp $list $objc $objv]
	    my condBr [my eq $code $0] $checkType $notList
	label notList:
	    # We're not a list and we know it right now
	    my store $1 $ecvar
	    my ret [my fail STRING]
	label checkType:
	    my condBr [my neq [my dereference $index 0 Tcl_Obj.typePtr] \
			[$api tclListType]] \
		$checkIndex $slowPath
	label checkIndex:
	    set len [my load $objc]
	    my condBr [my GetIndex {} $index $len idx] \
		$immediateIndex $slowPath

		    [my gep $dupe 0 Tcl_Obj.internalRep 0] \
		    TclList*] "listRep"]
	    set result [my Call tcl.list.index \
		    $list [my dereference $listRep 0 TclList.elemCount] \
		    [my gep $listRep 0 TclList.elements] $ecvar]
	    my dropReference $dupe
	    my ret $result




	}

	##### Function tcl.list.range #####
	#
	# Type signature: list:STRING * from:STRING * to:STRING -> STRING?
	#
	# Core of quadcode implementation ('listRangeImm')
	#
	# Wrapper around Tcl_NewListObj that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.range" STRING?<-STRING,STRING,STRING,int*]
	params list from to ecvar
	build {
	    noalias $ecvar
	    nonnull $list $from $to $ecvar
	    set objcVar [my alloc int]
	    set objvVar [my alloc STRING*]
	    set interp [$api tclInterp]
	    set result [$api Tcl_ListObjLength $interp $list $objcVar]
	    my condBr [my eq $result $0] $getFrom $error
	label getFrom:
	    set objc [my load $objcVar "objc"]
	    set endIndex [my sub $objc $1]
	    my condBr [my GetIndex $interp $from $endIndex from] $getTo $error
	label getTo:
	    my condBr [my GetIndex $interp $to $endIndex to] $clamp $error
	label clamp:
	    set from [my select [my lt $from ${-1}] \

	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.range1 #####
	#
	# Type signature: list:STRING * from:INT * to:INT -> STRING?
	#
	# Core of quadcode implementation ('listRangeImm')
	#
	# Wrapper around Tcl_NewListObj that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.range1" STRING?<-STRING,INT,INT,int*]
	params list from to ecvar
	build {
	    noalias $ecvar
	    nonnull $list $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set interp [$api tclInterp]
	    set from [my getInt32 $from "from"]
	    set to [my getInt32 $to "to"]
	    set result [$api Tcl_ListObjGetElements $interp $list $objc $objv]
	    my condBr [my eq $result $0] $clamp $error
	label clamp:
	    set objc [my load $objc]
	    set objv [my load $objv]
	    set from [my select [my lt $from ${-1}] \
		    [my add $from [my add $1 $objc]] \
		    [my min $objc $from] \
		    "from"]
	    set from [my max ${-1} $from "from"]

	label empty:
	    set r2 [$api Tcl_NewObj]
	    my br $ok
	label ok:
	    set sources [list $sublistInplaceDone $sublistNew $empty]
	    set result [my phi [list $list $r1 $r2] $sources "result"]
	    my addReference(STRING) $result
	    my ret [my ok $result]
	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.set #####
	#
	# Type signature: list:STRING * idxc:int * idxv:STRING* * elem:STRING
	#			* ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('lset')
	#
	# Approximately equivalent to TclLsetFlat

	set f [$m local "tcl.list.set" STRING?<-STRING,int,STRING*,STRING,int*]
	params list idxc idxv elem ecvar
	build {
	    noalias $idxv $ecvar
	    nonnull $list $idxv $elem $ecvar
	    set subList [my alloc STRING]
	    set chain [my alloc STRING]
	    set elemc [my alloc int]

	#			-> STRING?
	#
	# Core of quadcode implementation ('lset')
	#
	# Wrapper around TclListObjSetElement that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.set1" STRING?<-STRING,INT,STRING,int*]
	params list idx elem ecvar
	build {
	    noalias $ecvar
	    nonnull $list $elem $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set idx [my getInt32 $idx "index"]
	    set interp [$api tclInterp]
	    set duped [my Dedup list]
	    set code [$api Tcl_ListObjGetElements $interp $list $objc $objv]
	    my condBr [my eq $code $1] $out $rangeCheck
	label rangeCheck "range.check"
	    set objc [my load $objc]
	    my condBr [my or [my lt $idx $0] [my gt $idx $objc]] \
		$outRange $checkOperation
	label checkOperation "operation.check"
	    set rc [my refCount $list]
	    my condBr [my eq $idx $objc] $append $set
	label append:
	    $api Tcl_ListObjAppendElement {} $list $elem
	    my br $done
	label set:
	    set call [$api TclListObjSetElement {} $list $idx $elem]
	    my br $done
	label done:
	    my assume [my eq $rc [my refCount $list]]
	    $api TclInvalidateStringRep $list
	    my addReference(STRING) $list
	    my condBr [my shared $elem] $exit2 $exit3
	label exit3 "exit"
	    my addReference(STRING) $elem
	    my br $exit2
	label exit2 "exit"
	    my ret [my ok $list]
	label outRange "failure.outOfRange"

	    $api Tcl_SetObjResult $interp \
		[$api obj.constant "list index out of range"]
	    $api Tcl_SetObjErrorCode $interp \
		[$api obj.constant {TCL OPERATION LSET BADINDEX}]
	    my br $out
	label out "failure.exit"
	    my Call obj.cleanup $duped
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.setList #####
	#
	# Type signature: list:STRING * idxArg:STRING * elem:STRING
	#			* ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('lset')
	#
	# Approximately equivalent to TclLsetList

	set f [$m local "tcl.list.setList" STRING?<-STRING,STRING,STRING,int*]
	params list idxArg elem ecvar
	build {
	    noalias $ecvar
	    nonnull $list $idxArg $elem $ecvar
	    set ary [my alloc STRING]
	    set argc [my alloc int]
	    set argv [my alloc STRING*]

		$list [my load $argc] [my load $argv] $elem $ecvar]
	    my dropReference $copy
	    my ret $code
	}

	##### Function tcl.list.in #####
	#
	# Type signature: value:STRING * list:STRING * ecVar:int* -> ZEROONE?
	#
	# Core of quadcode implementation ('listIn')
	#
	# Determines if the value is present in the list, using simple string
	# comparison.

	set f [$m local "tcl.list.in" ZEROONE?<-STRING,STRING,int*]
	params value list ecVar
	build {
	    noalias $ecVar
	    nonnull $value $list $ecVar
	    set interp [$api tclInterp]
	    lassign [my GetString $value "string"] len1 bytes1
	    set lenVar [my alloc int]
	    set objvVar [my alloc STRING*]

	    set code [$api Tcl_ListObjGetElements $interp $list $lenVar $objvVar]
	    my condBr [my eq $code $0] $realCheck $fail
	label realCheck:
	    set objc [my load $lenVar "objc"]
	    set objv [my load $objvVar "objv"]
	    my condBr [my gt $objc $0] $loop $done
	label loop:
	    set i [PHI [Type int32] {$0 $iLoop} {$realCheck $loopNext} "i"]
	    set obj [my load [my getelementptr $objv [list $i]] "obj"]
	    lassign [my GetString $obj "element"] len2 bytes2
	    my condBr [my eq $len1 $len2] $loopCompare $loopNext
	label loopCompare:
	    my condBr [my eq [my memcmp $bytes1 $bytes2 $len1] $0] \
		$done $loopNext
	label loopNext:
	    set iLoop [set i [my add $i $1 "i"]]
	    my condBr [my lt $i $objc] $loop $done
	label fail:
	    my store $1 $ecVar
	    my ret [my fail ZEROONE]
	label done:
	    set flag [my phi [list [Const false bool] [Const false bool] [Const true bool]] \
		    [list $realCheck $loopNext $loopCompare] "flag"]
	    my ret [my ok $flag]
	}

	##### Function tcl.list.unshare #####
	#
	# Type signature: list:STRING -> STRING
	#
	# Core of quadcode implementation ('unshareList')
	#
	# Approximately equivalent to TclListObjCopy

	set f [$m local "tcl.list.unshare" STRING<-STRING]
	params list

	    my addReference(STRING) $copy
	    my ret $copy
	}

	##### Function tcl.list.foreach.start.step #####
	#
	# Type signature:
	#	nsteps:int?,list:STRING,stride:int->nsteps:int?
	#
	# Core of quadcode implementation ('foreachStart')
	#
	# Works with one pair of list and assignment pattern, making sure
	# that the list is really a list, and updating the number of iterations
	# according to the given stride.

	set f [$m local "tcl.list.foreach.start.step" \
		   int?<-int?,STRING,int]
	params steps_init list stride
	build {
	    noalias $list
	    nonnull $list
	    set objcVar [my alloc int]
	    set interp [$api tclInterp]
	    my condBr [my maybe $steps_init] $earlierError $listLength
	label earlierError:
	    my ret $steps_init
	label listLength:
	    set code [$api Tcl_ListObjLength $interp $list $objcVar]
	    my condBr [my eq $code $0] $lengthOk $lengthBad
	label lengthOk:
	    set steps_before [my unmaybe $steps_init]
	    set objc [my load $objcVar "objc"]
	    set count [my div [my add $objc [my sub $stride [Const 1 int]]] \
			   $stride "count"]
	    set stepsOk [my ok [my max $steps_before $count "steps"]]
	    my br $done
	label lengthBad:
	    set stepsBad [my fail int]
	    my br $done
	label done:
	    set steps [my phi [list $stepsOk $stepsBad] \
			   [list $lengthOk $lengthBad]]
	    my ret $steps
	}

	##### Function: tcl.list.foreach.start.finish #####
	#
	# Type signature: steps:int?,ecvar:int*->FAIL FOREACH
	#
	# After 'tcl.list.foreach.start.step' has run for each assignment

	params pair
	build {
	    my ret [my packInt32 [my extract $pair FOREACH.val]]
	}

	##### Function tcl.list.foreach.mayStep #####
	#
	# Type signature: pair:FOREACH -> ZEROONE
	#
	# Core of quadcode implementation ('foreachMayStep')
	#
	# Part of how lists are iterated over. This is broken up into several
	# pieces because of the number of different things assigned to. This
	# part gets whether the end of the iterations has been reached.

	set f [$m local "tcl.list.foreach.mayStep" ZEROONE<-FOREACH readnone]
	params pair
	build {
	    set val [my extract $pair FOREACH.val]
	    set max [my extract $pair FOREACH.max]
	    my ret [my lt $val $max]
	}

    #		Thunk class).
    #
    # Results:
    #	None.

    method DictionaryFunctions {api} {
	upvar 1 0 0 1 1


















	##### Function tcl.dict.exists1 #####
	#
	# Type signature: dict:STRING * key:STRING -> ZEROONE
	#
	# Tests if a key is in a dictionary.

	set f [$m local "tcl.dict.exists1" ZEROONE<-STRING,STRING]
	params dict key
	build {
	    nonnull $dict $key
	    set resvar [my alloc STRING "valueVar"]
	    my store [my null STRING] $resvar
	    set result [$api Tcl_DictObjGet {} $dict $key $resvar]
	    my ret [my and [my eq $result $0] \
		    [my nonnull [my load $resvar "value"]] \
		    "exists"]
	}

	##### Function tcl.dict.exists #####
	#
	# Type signature: dict:STRING * pathlen:int * pathobjs:STRING*
	#			* ecvar:int32* -> ZEROONE
	#
	# Gets a value by key from a dictionary.  Can fail if the "dict" is
	# not a valid dictionary.

	set f [$m local "tcl.dict.exists" ZEROONE<-STRING,int,STRING*]
	params dict keyc keyv
	build {
	    noalias $dict $keyv
	    nonnull $dict $keyv
	    set dummy [my alloc int "dummy"]
	    set resvar [my alloc STRING "valueVar"]
	    my condBr [my eq $keyc $0] $verify $exists

		    "exists"]
	label notOK:
	    my ret [Const false bool]
	}

	##### Function tcl.dict.size #####
	#
	# Type signature: dict:STRING * ecvar:int32* -> INT?
	#
	# Gets the size of a dictionary. Can fail if the "dict" is not a valid
	# dictionary.

	set f [$m local "tcl.dict.size" INT?<-STRING,int*]
	params dict ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $ecvar
	    set size [my alloc int "size"]
	    set interp [$api tclInterp]
	    set code [$api Tcl_DictObjSize $interp $dict $size]
	    my condBr [my eq $code $0] $ok $fail
	label ok:
	    my ret [my ok [my packInt32 [my load $size]]]
	label fail:
	    my store $1 $ecvar
	    my ret [my fail INT]
	}

	##### Function tcl.dict.get1 #####
	#
	# Type signature: dict:STRING * key:STRING * ecvar:int32* -> STRING?
	#
	# Gets a value by key from a dictionary.  Can fail if the "dict" is
	# not a valid dictionary.

	set f [$m local "tcl.dict.get1" STRING?<-STRING,STRING,int*]
	params dict key ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    set resvar [my alloc STRING "valueVar"]
	    set interp [$api tclInterp]
	    set result [$api Tcl_DictObjGet $interp $dict $key $resvar]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    set value [my load $resvar "value"]
	    my condBr [my nonnull $value] $return $fail
	label return:
	    my addReference(STRING) $value
	    my ret [my ok $value]
	label fail:
	    set keyval [$api Tcl_GetString $key]
	    $api Tcl_SetObjResult $interp \
		[$api Tcl_ObjPrintf [my constString \
			"key \"%s\" not known in dictionary"] \
		    $keyval]
	    $api Tcl_SetErrorCode $interp \
		[my constString TCL] [my constString LOOKUP] \
		[my constString DICT] $keyval {}
	    my br $notOK
	label notOK:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.get #####
	#
	# Type signature: dict:STRING * pathlen:int * pathobjs:STRING*
	#			* ecvar:int32* -> STRING?
	#
	# Gets a value by key from a dictionary.  Can fail if the "dict" is
	# not a valid dictionary.

	set f [$m local "tcl.dict.get" STRING?<-STRING,int,STRING*,int*]
	params dict keyc keyv ecvar
	build {
	    noalias $dict $keyv $ecvar
	    nonnull $dict $keyv $ecvar
	    set dummy [my alloc int "dummy"]
	    set resvar [my alloc STRING "valueVar"]
	    set interp [$api tclInterp]

	label notOK:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.get1.empty #####
	#
	# Type signature: dict:STRING * key:STRING * ecvar:int32* -> STRING!?
	#
	# Gets a value by key from a dictionary. Can only fail if the "dict"
	# is not a valid dictionary; an absent key in the terminal dictionary
	# is reported as an NEXIST result.

	set f [$m local "tcl.dict.get1.empty" STRING!?<-STRING,STRING,int*]
	params dict key ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    set resvar [my alloc STRING "valueVar"]
	    set interp [$api tclInterp]
	    set result [$api Tcl_DictObjGet $interp $dict $key $resvar]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    set value [my load $resvar "value"]
	    my condBr [my nonnull $value] $return $empty
	label return:
	    my addReference(STRING) $value
	    my ret [my ok [my just $value]]
	label empty:
	    my ret [my ok [my nothing STRING]]
	label notOK:
	    my store $1 $ecvar
	    my ret [my fail STRING!]
	}

	##### Function tcl.dict.set1 #####
	#
	# Type signature: dict:STRING * key:STRING * value:STRING
	#			* ecvar:int32* -> STRING?
	#
	# Sets a key in a dictionary to map to a value.  Can fail if the
	# "dict" is not a valid dictionary.

	set f [$m local "tcl.dict.set1" STRING?<-STRING,STRING,STRING,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $value $ecvar
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjPut $interp $dict $key $value]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    my addReference(STRING) $dict
	    my condBr [my shared $value] $exit2 $exit3
	label exit3 "exit"
	    my addReference(STRING) $value
	    my br $exit2
	label exit2 "exit"
	    my ret [my ok $dict]
	label notOK:
	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.set #####
	#
	# Type signature: dict:STRING * pathlen:int * pathobjs:STRING*
	#			* value:STRING * ecvar:int32* -> STRING?
	#
	# Sets a key (or rather a key path) in a dictionary to map to a value.
	# Can fail if the "dict" is not a valid dictionary.

	set f [$m local "tcl.dict.set" STRING?<-STRING,int,STRING*,STRING,int*]
	params dict pathlen pathobjs value ecvar
	build {
	    noalias $pathobjs $ecvar
	    nonnull $dict $pathobjs $value $ecvar
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjPutKeyList $interp $dict $pathlen $pathobjs $value]

	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.unset1 #####
	#
	# Type signature: dict:STRING * key:STRING * ecvar:int32* -> STRING?
	#
	# Removes a key from a dictionary.  Can fail if the "dict" is not a
	# valid dictionary.

	set f [$m local "tcl.dict.unset1" STRING?<-STRING,STRING,int*]
	params dict key ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjRemove $interp $dict $key]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    my addReference(STRING) $dict
	    my ret [my ok $dict]
	label notOK:
	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.unset #####
	#
	# Type signature: dict:STRING * pathlen:int * pathobjs:STRING*
	#			* ecvar:int32* -> STRING?
	#
	# Removes a key (or rather a key path) from a dictionary. Can fail if
	# the "dict" is not a valid dictionary.

	set f [$m local "tcl.dict.unset" STRING?<-STRING,int,STRING*,int*]
	params dict pathlen pathobjs ecvar
	build {
	    noalias $dict $pathobjs $ecvar
	    nonnull $dict $pathobjs $ecvar
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjRemoveKeyList $interp $dict $pathlen $pathobjs]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    my ret [my ok $dict]
	label notOK:
	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.set1.empty #####
	#
	# Type signature: dict:STRING * key:STRING * value:STRING!
	#			* ecvar:int32* -> STRING?
	#
	# Sets a key in a dictionary to map to a value, or removes the mapping
	# if the value is NEXIST. Can fail if the "dict" is not a valid
	# dictionary.

	set f [$m local "tcl.dict.set1.empty" \
		   STRING?<-STRING,STRING,STRING!,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    my condBr [my exists $value] $reallySet $reallyUnset
	label reallySet "real.set"
	    set value [my unmaybe $value]
	    my ret [my Call tcl.dict.set1 $dict $key $value $ecvar]
	label reallyUnset "real.unset"
	    my ret [my Call tcl.dict.unset1 $dict $key $ecvar]
	}

	##### Function tcl.dict.addIterReference #####
	#
	# Type signature: iter:DICTITER -> void
	#
	# Increments the reference count inside a dictionary iteration state.

	label release:
	    my Call tcl.dict.addIterReference [my unmaybe $value]
	    my ret
	}

	##### Function tcl.dict.iterStart #####
	#
	# Type signature: dict:STRING * ecvar:int* -> DICTITER?
	#
	# Starts iterating over a dictionary. The current state of the
	# iteration (assuming we don't get an error) is stored inside the
	# returned iteration state value.

	set f [$m local "tcl.dict.iterStart" DICTITER?<-STRING,int*]
	params dict ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $ecvar
	    set done [my alloc int "done"]
	    set interp [$api tclInterp]
	    set iter [$api cknew DICTFOR]
	    set key [my gep $iter 0 DICTFOR.key]
	    SetValueName $key "keyPtr"
	    set value [my gep $iter 0 DICTFOR.value]
	    SetValueName $value "valuePtr"
	    set search [my gep $iter 0 DICTFOR.search]
	    set code [$api Tcl_DictObjFirst $interp $dict \
			$search $key $value $done]
	    my condBr [my eq $code $0] $ok $failed
	label ok:
	    my storeInStruct $iter DICTFOR.dict $dict
	    my storeInStruct $iter DICTFOR.ref $0
	    my storeInStruct $iter DICTFOR.done [my neq [my load $done] $0]
	    my addReference(STRING) $dict
	    my Call tcl.dict.addIterReference $iter
	    my ret [my ok $iter]
	label failed:
	    $api ckfree $iter
	    my store $1 $ecvar
	    my ret [my fail DICTITER]
	}

	##### Function tcl.dict.iterNext #####
	#
	# Type signature: iter:DICTITER -> DICTITER
	#
	# Continues iterating over a dictionary. The current state of the

	    set obj [my phi [list $obj $new] [list $real $alloc] "obj"]
	    my addReference(STRING) $obj
	    my ret $obj
	}

	##### Function tcl.dict.iterDone #####
	#
	# Type signature: iter:DICTITER -> ZEROONE
	#
	# Gets whether this iteration of the dictionary has finished.

	set f [$m local "tcl.dict.iterDone" ZEROONE<-DICTITER]
	params iter
	build {
	    nonnull $iter
	    my ret [my dereference $iter 0 DICTFOR.done]
	}

	##### Function tcl.dict.append #####
	#
	# Type signature: dict:STRING * key:STRING * value:STRING
	#			* ecvar:int32* -> STRING?
	#
	# Appends to value in a dictionary indicated by a key.  Can fail if the
	# "dict" is not a valid dictionary.

	set f [$m local "tcl.dict.append" STRING?<-STRING,STRING,STRING,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $value $ecvar
	    set valuePtr [my alloc STRING "valuePtr"]
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjGet $interp $dict $key $valuePtr]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    set dictVal [my load $valuePtr "value.in.dict"]
	    my condBr [my nonnull $dictVal] $append $set
	label set:
	    $api Tcl_DictObjPut {} $dict $key $value
	    my br $done
	label append:
	    my condBr [my shared $dictVal] $dupePut $directUpdate
	label directUpdate:
	    $api Tcl_AppendObjToObj $dictVal $value
	    $api TclInvalidateStringRep $dict
	    my br $done
	label dupePut:
	    set dictVal2 [$api Tcl_DuplicateObj $dictVal]
	    $api Tcl_AppendObjToObj $dictVal2 $value
	    set c [$api Tcl_DictObjPut {} $dict $key $dictVal2]
	    AddCallAttribute $c 3 nocapture
	    my br $done
	label done:
	    my addReference(STRING) $dict
	    my ret [my ok $dict]
	label notOK:
	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.incr #####
	#
	# Type signature: dict:STRING * key:STRING * value:INT
	#			* ecvar:int32* -> STRING?
	#
	# Adds an integer to an integer in a dictionary indicated by a key.
	# Can fail if the "dict" is not a valid dictionary or the value
	# pointed to is not a valid integer.

	set f [$m local "tcl.dict.incr" STRING?<-STRING,STRING,INT,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    set valuePtr [my alloc STRING "valuePtr"]
	    set intVar [my alloc int64 "intPtr"]
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjGet $interp $dict $key $valuePtr]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    set dictVal [my load $valuePtr "value.in.dict"]
	    my condBr [my nonnull $dictVal] $add $set
	label set:
	    set strVal [my stringify(INT) $value "value"]
	    my br $done
	label add:
	    # TODO: Revisit once we support bignums

	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.lappend #####
	#
	# Type signature: dict:STRING * key:STRING * value:STRING
	#			* ecvar:int32* -> STRING?
	#
	# Appends to list in a dictionary indicated by a key.  Can fail if the
	# "dict" is not a valid dictionary or the value pointed to is not a
	# valid list.

	set f [$m local "tcl.dict.lappend" STRING?<-STRING,STRING,STRING,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $value $ecvar
	    set valuePtr [my alloc STRING "valuePtr"]
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjGet $interp $dict $key $valuePtr]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    set dictVal [my load $valuePtr "value.in.dict"]
	    my condBr [my nonnull $dictVal] $append $set
	label set:
	    my store $value $valuePtr
	    set newlist [$api Tcl_NewListObj $1 $valuePtr]
	    $api Tcl_DictObjPut {} $dict $key $newlist
	    my br $done

    #	None.

    method StringComparisonFunctions {api} {
	upvar 1 sizeof sizeof 0 0 1 1

	##### Function tcl.streq #####
	#
	# Type signature: value1Ptr:STRING * value2Ptr:STRING -> ZEROONE
	#
	# Quadcode implementation ('streq')
	#
	# Returns whether the two string arguments are equal.

	set f [$m local "tcl.streq" ZEROONE<-STRING,STRING]
	params v1:value1Ptr v2:value2Ptr
	build {
	    nonnull $v1 $v2
	    my condBr [my eq $v1 $v2] $identical $nexttest
	label nexttest:
	    my condBr [my and [my isByteArray $v1] [my isByteArray $v2]] \
		$cmpBA $nexttest2

	    set diff [my phi [list $diffBA $diffUni $diffUtf] $sources]
	    my ret [my select [my eq $match $0] $diff $match]
	}

	##### Function tcl.strmatch #####
	#
	# Type signature: nocase:INT * pattern:STRING * string:STRING
	#			-> ZEROONE
	#
	# Quadcode implementation ('strmatch')
	#
	# Returns whether the glob pattern in 'pattern' matches 'string'. If
	# 'nocase' is non-zero, performs the match case-insensitively.

	set f [$m local "tcl.strmatch" ZEROONE<-INT,STRING,STRING]
	params nocaseInt:nocase patternObj:pattern stringObj:string
	build {
	    nonnull $patternObj $stringObj
	    set nocase [my getInt32 $nocaseInt]
	    my condBr [my isUnicodeString $patternObj] $test2 $ordinary
	label test2:
	    my condBr [my isUnicodeString $stringObj] $unicode $ordinary

		    $nocase]
	    my ret [my neq $match $0]
	}

	##### Function tcl.regexp #####
	#
	# Type signature: flags:INT * regexp:STRING * string:STRING
	#			* errVar:int* -> ZEROONE?
	#
	# Quadcode implementation ('regexp')
	#
	# Returns whether the regular expression in 'regexp' matches 'string'
	# as a WRAPPED BOOLEAN. The 'flags' control things like whether we are
	# matching case-insensitively. If the code fails (generally because of
	# a bad regular expression) then the result is a Nothing. The variable
	# pointed to by 'errVar' is set to the relevant Tcl result code.

	set f [$m local "tcl.regexp" ZEROONE?<-INT,STRING,STRING,int*]
	params flags patternObj:regexp stringObj:string errVar:errorCode
	build {
	    noalias $errVar
	    nonnull $patternObj $stringObj $errVar
	    set interp [$api tclInterp]
	    set RE [$api Tcl_GetRegExpFromObj $interp $patternObj \
		    [my getInt32 $flags]]
	    my condBr [my nonnull $RE] $exec $err
	label exec "re.exec"
	    set match [$api Tcl_RegExpExecObj $interp $RE $stringObj $0 $0 $0]
	    my condBr [my ge $match $0] $done $err
	label done "re.done"
	    my store $0 $errVar
	    my ret [my ok [my gt $match $0]]
	label err "re.error"
	    my store $1 $errVar
	    my ret [my fail ZEROONE]
	}

    }

    # Builder:@apiFunctions --
    #
    #	Generate the quadcode operator implementations that require access to

	# Type signature: returnCode:INT -> STRING
	#
	# Quadcode implementation ('returnOptions')
	#
	# Returns the return options dictionary. Note that this requires the
	# current Tcl result code in order to work correctly.

	set f [$module local "tcl.getreturnopts" STRING<-INT]
	params value:returnCode
	build {
	    set code [my int.32 $value "code"]
	    set opts [$api Tcl_GetReturnOptions [$api tclInterp] $code]
	    SetValueName $opts "optionsObj"
	    my addReference(STRING) $opts
	    my ret $opts
	}

	##### Function tcl.initExceptionOptions #####
	#
	# Type signature: objPtr:STRING * dictPtr:STRING -> int
	#
	# Initialises the return options from what we know about an exception.

	set f [$module local "tcl.initExceptionOptions" int<-STRING,STRING]
	params result:objPtr opts:dictPtr
	build {
	    nonnull $result $opts
	    set interp [$api tclInterp]
	    set code [$api Tcl_SetReturnOptions $interp $opts]
	    my switch $code $other 0 $ok 1 $error
	label ok:

	    my store [my or [my load $field] [Const 0x800]] $field
	    my ret
	}

	##### Function tcl.processReturn #####
	#
	# Type signature: result:STRING * code:int * level:int
	#			* returnOpts:STRING -> int
	#
	# Initialises the return options from what we know about an exception.
	# Analogous to TclProcessReturn, which isn't exposed.
	#
	# Note that returnOpts may be NULL; that's equivalent to an empty
	# options dictionary, but is special-cased so it is handled more
	# efficiently by the optimizer.

	set f [$module local "tcl.processReturn" int<-STRING,int,int,STRING]
	params result code level returnOpts
	build {
	    nonnull $result
	    set valuePtr [my alloc STRING "valuePtr"]
	    set infoLen [my alloc int "infoLen"]
	    set objcPtr [my alloc int]
	    set objvPtr [my alloc STRING*]

	    my br $done
	label done:
	    my ret
	}

	##### Function tcl.booleanTest #####
	#
	# Type signature: objPtr:Tcl_Obj* -> ZEROONE
	#
	# Part of quadcode implementation ('isBoolean')
	#
	# Returns whether the string 'objPtr' is a Boolean bareword

	set f [$m local "tcl.booleanTest" ZEROONE<-Tcl_Obj*]
	params objPtr
	build {
	    nonnull $objPtr
	    set NULL [my null Interp*]
	    set code [my setFromAny [$api tclBooleanType] $NULL $objPtr]
	    my ret [my eq $code $0]
	}

	label fail:
	    my store $code $ecvar
	    my ret [my fail STRING $code]
	}

	##### Function tcl.existsOrError #####
	#
	# Type signature: exists:int1 * message:STRING * ecvar:int* -> int1
	#
	# Conditionally generates an error about a non-existing variable.
	# Generated like this to avoid introducing extra basic blocks at the
	# pre-optimized LLVM level.

	set f [$module local "tcl.existsOrError" int1<-int1,STRING,STRING,int*]
	params exists message exception ecvar
	build {
	    noalias $message $ecvar
	    nonnull $message $exception $ecvar
	    my condBr $exists $doError $done
	label doError:
	    my initException $exception $message $ecvar
	    my br $done
	label done:
	    my ret $exists
	}

	##### Function tcl.not.string #####
	#
	# Type signature: value:STRING * ecvar:int* -> ZEROONE?
	#
	# Quadcode implementation ('not').
	#
	# Logical negation of 'value'.

	set f [$m local "tcl.not.string" ZEROONE?<-STRING,int*]
	params value ecvar
	build {
	    noalias $ecvar
	    nonnull $value $ecvar
	    set bvar [my alloc int]
	    set interp [$api tclInterp]
	    set code [$api Tcl_GetBooleanFromObj $interp $value $bvar]
	    my condBr [my eq $code [Const 0]] $ok $fail
	label fail:
	    my store [Const 1] $ecvar
	    my ret [my fail ZEROONE]
	label ok:
	    my ret [my ok [my neq [my load $bvar "bool"] [Const 1]]]
	}

	my VariableHelperFunctions $api
	my @variableFunctions $api
	my @numericConverterFunctions $api

	    }
	    {{IMPURE DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }






	    {DICT STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }






	    {LIST STRING} {
		append body2 { $} [lindex $f 0]






	    }
	    {DICT LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} {EMPTY LIST}} {
		append body2 { $} [lindex $f 0]
	    }

	    $b condBr [$b maybe $result] $isFail $next
	    $isFail build $b {
		$b ret [$b extract $result 0]
	    }
	    $next build-in $b
	    set result [$b unmaybe $result]
	}


	set resultType [string map {{EMPTY STRING} STRING} [string map {DICT STRING LIST STRING} $resultType]]
	if {[regexp "^IMPURE (.*)" $resultType -> payload]} {
	    if {$payload ne "STRING"} {
		set result [$b impure.string $result]
		SetValueName $result @result
	    }
	    set resultType STRING
	}

		set value [list temp $depth]
		set key [list temp [incr depth]]
		set done [list temp [incr depth]]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my generate-dict-domain-check $pc [lindex $insn 0] $dict
		my quads purify {temp opd0} $dict
		my error-quads $pc dictIterStart $var {temp opd0}
		my quads dictIterKey $key $var
		my quads dictIterValue $value $var
		my quads dictIterDone $done $var
	    }
	    dictNext {
		set var [my index-to-var [lindex $insn 1]]
		set value [list temp $depth]

		set val [list temp [incr depth -1]]
		set idx 0
		foreach v [dict get $aux variables] {
		    set r [my index-to-var $v]
		    my generate-scalar-check $pc $r {TCL WRITE VARNAME} \
			"can't set \"%s\": variable is array"
		    my error-quads $pc listIndex $mid $val [list literal $idx]
		    my error-quads $pc dictGetOrNexist $r $var $mid
		    incr idx
		}
	    }
	    dictUpdateEnd {
		set var [my index-to-var [lindex $insn 1]]
		set auxNum [string range [lindex $insn 2] 1 end]
		set aux [lindex [dict get $bytecode auxiliary] $auxNum]
		set key [list temp opnd1]
		set isary [list temp opnd2]
		set mid [list temp opnd3]
		set updating [list temp opnd4]
		set val [list temp [incr depth -1]]
		set idx 0
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't write \"%s\": variable is array"

		my quads copy $updating $var
		foreach v [dict get $aux variables] {
		    set r [my index-to-var $v]
		    my error-quads $pc listIndex $key $val [list literal $idx]
		    incr idx
		    # Convert an ARRAY into a NEXIST here; ARRAY is unreadable
		    # so treat as NEXIST...
		    my quads arrayExists $isary $r
		    set n [llength $quads]
		    my quads jumpFalse [list pc [expr {$n + 3}]] $isary
		    my quads copy $mid Nothing
		    my quads jump [list pc [expr {$n + 4}]]
		    my quads extractScalar $mid $r
		    # Write the value to the right key of the dict
		    my error-quads $pc dictSetOrUnset $updating $updating $key $mid
		}
		my quads copy $var $updating
	    }
	    unsetScalar {
		# TODO - This doesn't complain on unsetting a nonexistent
		#        variable, it ignores '-nocomplain'
		set var [my index-to-var [lindex $insn 2]]

		my quads purify {temp opd0} $val
		my quads dictExists $r {temp opd0} {*}[lreverse $q]
	    }
	    dictSet {
		set idxNum [expr [lindex $insn 1]]
		set var [my index-to-var [lindex $insn 2]]
		set val [list temp [incr depth -1]]

		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
		}
		set r [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var



		my error-quads $pc dictSet $r {temp opd0} $val {*}[lreverse $q]

		my quads copy $var $r
	    }
	    dictUnset {
		set idxNum [expr [lindex $insn 1]]
		set var [my index-to-var [lindex $insn 2]]
		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
		}
		set r [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var



		my error-quads $pc dictUnset $r {temp opd0} {*}[lreverse $q]

		my quads copy $var $r
	    }
	    dictAppend - dictLappend {
		set var [my index-to-var [lindex $insn 1]]
		set val [list temp [incr depth -1]]
		set key [list temp [incr depth -1]]
		set res [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var




		my error-quads $pc [lindex $insn 0] $res {temp opd0} $key $val

		my quads copy $var $res
	    }
	    dictIncrImm {
		set delta [list literal [lindex $insn 1]]
		set var [my index-to-var [lindex $insn 2]]
		set key [list temp [incr depth -1]]
		set res [list temp $depth]

	eq -
	ge -
	gt -
	instanceOf -
	isBoolean -
	land -
	le -

	lor -
	lt -
	neq -
	strclass -
	streq -
	strmatch -
	strneq {
	    return $ZEROONE
	}
	not {
	    set t [typeOfOperand $types [lindex $q 2]]
	    if {istype($t,$NUMERIC|$BOOLWORD)} {
		return $ZEROONE
	    } else {
		puts "which might FAIL"
		return [expr {$ZEROONE | $FAIL}]
	    }
	}
	regexp - listIn {
	    return [expr {$ZEROONE | $FAIL}]
	}
	listLength - dictSize {
	    return [expr {$INT | $FAIL}]
	}
	phi {
	    set r 0
	    foreach {from operand} [lrange $q 2 end] {
		set r [expr {$r | [typeOfOperand $types $operand]}]
	    }
	    return $r

	extractCallFrame {
	    # Trim the non-callframe part
	    return $CALLFRAME
	}
	list - unshareList {
	    return $LIST
	}
	result - returnOptions -


	dictIterKey - dictIterValue -
	concat - strcat - strmap - strtrim - strcase {
	    return $STRING
	}
	foreachAdvance {
	    return $FOREACH
	}
	foreachStart {
	    return [expr {$FOREACH | $FAIL}]
	}
	listAppend - listConcat - listIndex - listRange - listSet {




















	    return [expr {$LIST | $FAIL}]
	}




	strindex - strrange - strreplace - dictGet {
	    return [expr {$STRING | $FAIL}]
	}
	dictSet - dictSetOrUnset - dictUnset -
















	dictAppend - dictIncr - dictLappend {
	    return [expr {$DICT | $FAIL}]
	}
	dictGetOrNexist {
	    return [expr {$STRING | $FAIL | $NEXIST}]
	}
	arrayGet {
	    return [expr {$STRING | $NEXIST}]
	}
	arraySet - arrayUnset - initArray {
	    return $ARRAY
	}
	dictIterStart {
	    return [expr {$DICTITER | $FAIL}]
	}
	dictIterNext {
	    return $DICTITER
	}
	initIfNotExists {
	    set vartype [typeOfOperand $types [lindex $q 2]]
	    set deftype [typeOfOperand $types [lindex $q 3]]
	    return [expr {$deftype | ($vartype & ~$NEXIST)}]
	}