Tcl_CreateInterp reset
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::namespace'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 6605: (
	::namespace path {}
	namespace eval Helpers {
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	}
	proc UnlinkLinkedCommand {cmd args} {
		if {[namespace which $cmd] ne {}} {
			rename $cmd {}
		}
	}
	proc DelegateName {class} {
		string cat [info object namespace $class] {:: oo ::delegate}
	}
	proc MixinClassDelegates {class} {
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	}
	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse 6605: (
	::namespace path {}
	namespace eval Helpers {
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	}
	proc UnlinkLinkedCommand {cmd args} {
		if {[namespace which $cmd] ne {}} {
			rename $cmd {}
		}
	}
	proc DelegateName {class} {
		string cat [info object namespace $class] {:: oo ::delegate}
	}
	proc MixinClassDelegates {class} {
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	}
	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(path)
	CompileCommandTokens [  3] type 4 comp 0 4:(path)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 6583: (	namespace eval Helpers {
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	}
	proc UnlinkLinkedCommand {cmd args} {
		if {[namespace which $cmd] ne {}} {
			rename $cmd {}
		}
	}
	proc DelegateName {class} {
		string cat [info object namespace $class] {:: oo ::delegate}
	}
	proc MixinClassDelegates {class} {
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	}
	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 7:(Helpers)
	CompileCommandTokens [  5] type 4 comp 0 7:(Helpers)
	CompileCommandTokens [  6] type 2 comp 1 1539:({
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	})
	CompileCommandTokens [  7] type 4 comp 0 1537:(
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5019: (	proc UnlinkLinkedCommand {cmd args} {
		if {[namespace which $cmd] ne {}} {
			rename $cmd {}
		}
	}
	proc DelegateName {class} {
		string cat [info object namespace $class] {:: oo ::delegate}
	}
	proc MixinClassDelegates {class} {
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	}
	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 19:(UnlinkLinkedCommand)
	CompileCommandTokens [  3] type 4 comp 0 19:(UnlinkLinkedCommand)
	CompileCommandTokens [  4] type 2 comp 1 10:({cmd args})
	CompileCommandTokens [  5] type 4 comp 0 8:(cmd args)
	CompileCommandTokens [  6] type 2 comp 1 64:({
		if {[namespace which $cmd] ne {}} {
			rename $cmd {}
		}
	})
	CompileCommandTokens [  7] type 4 comp 0 62:(
		if {[namespace which $cmd] ne {}} {
			rename $cmd {}
		}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4917: (	proc DelegateName {class} {
		string cat [info object namespace $class] {:: oo ::delegate}
	}
	proc MixinClassDelegates {class} {
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	}
	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 12:(DelegateName)
	CompileCommandTokens [  3] type 4 comp 0 12:(DelegateName)
	CompileCommandTokens [  4] type 2 comp 1 7:({class})
	CompileCommandTokens [  5] type 4 comp 0 5:(class)
	CompileCommandTokens [  6] type 2 comp 1 67:({
		string cat [info object namespace $class] {:: oo ::delegate}
	})
	CompileCommandTokens [  7] type 4 comp 0 65:(
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4822: (	proc MixinClassDelegates {class} {
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	}
	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 19:(MixinClassDelegates)
	CompileCommandTokens [  3] type 4 comp 0 19:(MixinClassDelegates)
	CompileCommandTokens [  4] type 2 comp 1 7:({class})
	CompileCommandTokens [  5] type 4 comp 0 5:(class)
	CompileCommandTokens [  6] type 2 comp 1 402:({
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	})
	CompileCommandTokens [  7] type 4 comp 0 400:(
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4385: (	proc UpdateClassDelegatesAfterClone {originObject targetObject} {
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	}
	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 30:(UpdateClassDelegatesAfterClone)
	CompileCommandTokens [  3] type 4 comp 0 30:(UpdateClassDelegatesAfterClone)
	CompileCommandTokens [  4] type 2 comp 1 27:({originObject targetObject})
	CompileCommandTokens [  5] type 4 comp 0 25:(originObject targetObject)
	CompileCommandTokens [  6] type 2 comp 1 427:({
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	})
	CompileCommandTokens [  7] type 4 comp 0 425:(
		set originDelegate [DelegateName $originObject]
		set targetDelegate [DelegateName $targetObject]
		if {
			[info object isa class $originDelegate]
			&& ![info object isa class $targetDelegate]
		} then {
			copy $originDelegate $targetDelegate
			objdefine $targetObject ::oo::objdefine::mixin -set  {*}[lmap c [info object mixin $targetObject] {
					if {$c eq $originDelegate} {set targetDelegate} {set c}
				}]
		}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3892: (	proc define::classmethod {name {args {}} {body {}}} {
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	}
	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 19:(define::classmethod)
	CompileCommandTokens [  3] type 4 comp 0 19:(define::classmethod)
	CompileCommandTokens [  4] type 2 comp 1 26:({name {args {}} {body {}}})
	CompileCommandTokens [  5] type 4 comp 0 24:(name {args {}} {body {}})
	CompileCommandTokens [  6] type 2 comp 1 379:({
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	})
	CompileCommandTokens [  7] type 4 comp 0 377:(
		::set argc [::llength [::info level 0]]
		::if {$argc == 3} {
			::return -code error -errorcode {TCL WRONGARGS} [::format  {wrong # args: should be "%s name ?args body?"}  [::lindex [::info level 0] 0]]
		}
		::set cls [::uplevel 1 self]
		::if {$argc == 4} {
			::oo::define [::oo::DelegateName $cls] method $name $args $body
		}
		::tailcall forward $name myclass $name
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3459: (	proc define::initialise {body} {
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	}
	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 18:(define::initialise)
	CompileCommandTokens [  3] type 4 comp 0 18:(define::initialise)
	CompileCommandTokens [  4] type 2 comp 1 6:({body})
	CompileCommandTokens [  5] type 4 comp 0 4:(body)
	CompileCommandTokens [  6] type 2 comp 1 107:({
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	})
	CompileCommandTokens [  7] type 4 comp 0 105:(
		::set clsns [::info object namespace [::uplevel 1 self]]
		::tailcall apply [::list {} $body $clsns]
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3319: (	namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	}
	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 6:(define)
	CompileCommandTokens [  5] type 4 comp 0 6:(define)
	CompileCommandTokens [  6] type 2 comp 1 196:({
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	})
	CompileCommandTokens [  7] type 4 comp 0 194:(
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3099: (	define Slot {
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	}
	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(define)
	CompileCommandTokens [  1] type 4 comp 0 6:(define)
	CompileCommandTokens [  2] type 2 comp 1 4:(Slot)
	CompileCommandTokens [  3] type 4 comp 0 4:(Slot)
	CompileCommandTokens [  4] type 2 comp 1 1423:({
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	})
	CompileCommandTokens [  5] type 4 comp 0 1421:(
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1662: (	objdefine define::superclass forward --default-operation my -set
	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 9:(objdefine)
	CompileCommandTokens [  1] type 4 comp 0 9:(objdefine)
	CompileCommandTokens [  2] type 2 comp 1 18:(define::superclass)
	CompileCommandTokens [  3] type 4 comp 0 18:(define::superclass)
	CompileCommandTokens [  4] type 2 comp 1 7:(forward)
	CompileCommandTokens [  5] type 4 comp 0 7:(forward)
	CompileCommandTokens [  6] type 2 comp 1 19:(--default-operation)
	CompileCommandTokens [  7] type 4 comp 0 19:(--default-operation)
	CompileCommandTokens [  8] type 2 comp 1 2:(my)
	CompileCommandTokens [  9] type 4 comp 0 2:(my)
	CompileCommandTokens [ 10] type 2 comp 1 4:(-set)
	CompileCommandTokens [ 11] type 4 comp 0 4:(-set)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1596: (	objdefine define::mixin forward --default-operation my -set
	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 9:(objdefine)
	CompileCommandTokens [  1] type 4 comp 0 9:(objdefine)
	CompileCommandTokens [  2] type 2 comp 1 13:(define::mixin)
	CompileCommandTokens [  3] type 4 comp 0 13:(define::mixin)
	CompileCommandTokens [  4] type 2 comp 1 7:(forward)
	CompileCommandTokens [  5] type 4 comp 0 7:(forward)
	CompileCommandTokens [  6] type 2 comp 1 19:(--default-operation)
	CompileCommandTokens [  7] type 4 comp 0 19:(--default-operation)
	CompileCommandTokens [  8] type 2 comp 1 2:(my)
	CompileCommandTokens [  9] type 4 comp 0 2:(my)
	CompileCommandTokens [ 10] type 2 comp 1 4:(-set)
	CompileCommandTokens [ 11] type 4 comp 0 4:(-set)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1535: (	objdefine objdefine::mixin forward --default-operation my -set
	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 9:(objdefine)
	CompileCommandTokens [  1] type 4 comp 0 9:(objdefine)
	CompileCommandTokens [  2] type 2 comp 1 16:(objdefine::mixin)
	CompileCommandTokens [  3] type 4 comp 0 16:(objdefine::mixin)
	CompileCommandTokens [  4] type 2 comp 1 7:(forward)
	CompileCommandTokens [  5] type 4 comp 0 7:(forward)
	CompileCommandTokens [  6] type 2 comp 1 19:(--default-operation)
	CompileCommandTokens [  7] type 4 comp 0 19:(--default-operation)
	CompileCommandTokens [  8] type 2 comp 1 2:(my)
	CompileCommandTokens [  9] type 4 comp 0 2:(my)
	CompileCommandTokens [ 10] type 2 comp 1 4:(-set)
	CompileCommandTokens [ 11] type 4 comp 0 4:(-set)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1471: (	define object method <cloned> {originObject} {
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	}
	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 6:(define)
	CompileCommandTokens [  1] type 4 comp 0 6:(define)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 6:(method)
	CompileCommandTokens [  5] type 4 comp 0 6:(method)
	CompileCommandTokens [  6] type 2 comp 1 8:(<cloned>)
	CompileCommandTokens [  7] type 4 comp 0 8:(<cloned>)
	CompileCommandTokens [  8] type 2 comp 1 14:({originObject})
	CompileCommandTokens [  9] type 4 comp 0 12:(originObject)
	CompileCommandTokens [ 10] type 2 comp 1 654:({
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	})
	CompileCommandTokens [ 11] type 4 comp 0 652:(
		foreach p [info procs [info object namespace $originObject]::*] {
			set args [info args $p]
			set idx -1
			foreach a $args {
				if {[info default $p $a d]} {
					lset args [incr idx] [list $a $d]
				} else {
					lset args [incr idx] [list $a]
				}
			}
			set b [info body $p]
			set p [namespace tail $p]
			proc $p $args $b
		}
		foreach v [info vars [info object namespace $originObject]::*] {
			upvar 0 $v vOrigin
			namespace upvar [namespace current] [namespace tail $v] vNew
			if {[info exists vOrigin]} {
				if {[array exists vOrigin]} {
					array set vNew [array get vOrigin]
				} else {
					set vNew $vOrigin
				}
			}
		}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 770: (	define class method <cloned> {originObject} {
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	}
	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 6:(define)
	CompileCommandTokens [  1] type 4 comp 0 6:(define)
	CompileCommandTokens [  2] type 2 comp 1 5:(class)
	CompileCommandTokens [  3] type 4 comp 0 5:(class)
	CompileCommandTokens [  4] type 2 comp 1 6:(method)
	CompileCommandTokens [  5] type 4 comp 0 6:(method)
	CompileCommandTokens [  6] type 2 comp 1 8:(<cloned>)
	CompileCommandTokens [  7] type 4 comp 0 8:(<cloned>)
	CompileCommandTokens [  8] type 2 comp 1 14:({originObject})
	CompileCommandTokens [  9] type 4 comp 0 12:(originObject)
	CompileCommandTokens [ 10] type 2 comp 1 85:({
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	})
	CompileCommandTokens [ 11] type 4 comp 0 83:(
		next $originObject
		::oo::UpdateClassDelegatesAfterClone $originObject [self]
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 639: (	class create singleton {
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	}
	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 5:(class)
	CompileCommandTokens [  1] type 4 comp 0 5:(class)
	CompileCommandTokens [  2] type 2 comp 1 6:(create)
	CompileCommandTokens [  3] type 4 comp 0 6:(create)
	CompileCommandTokens [  4] type 2 comp 1 9:(singleton)
	CompileCommandTokens [  5] type 4 comp 0 9:(singleton)
	CompileCommandTokens [  6] type 2 comp 1 525:({
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	})
	CompileCommandTokens [  7] type 4 comp 0 523:(
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 89: (	class create abstract {
		superclass class
		unexport create createWithNamespace new
	}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 5:(class)
	CompileCommandTokens [  1] type 4 comp 0 5:(class)
	CompileCommandTokens [  2] type 2 comp 1 6:(create)
	CompileCommandTokens [  3] type 4 comp 0 6:(create)
	CompileCommandTokens [  4] type 2 comp 1 8:(abstract)
	CompileCommandTokens [  5] type 4 comp 0 8:(abstract)
	CompileCommandTokens [  6] type 2 comp 1 65:({
		superclass class
		unexport create createWithNamespace new
	})
	CompileCommandTokens [  7] type 4 comp 0 63:(
		superclass class
		unexport create createWithNamespace new
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3830db88
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e30
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::path'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 1562: (namespace eval Helpers {
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	})
	TclCompileScript parse 1562: (namespace eval Helpers {
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	})
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 7:(Helpers)
	CompileCommandTokens [  5] type 4 comp 0 7:(Helpers)
	CompileCommandTokens [  6] type 2 comp 1 1539:({
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	})
	CompileCommandTokens [  7] type 4 comp 0 1537:(
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3830eaa8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240eb0
TEBCresume ip 0x558f3823dce8 td 0x558f38240eb0 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 1537: (
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse 1537: (
		::namespace path {}
		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(path)
	CompileCommandTokens [  3] type 4 comp 0 4:(path)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1514: (		proc callback {method args} {
			list [uplevel 1 {::namespace which my}] $method {*}$args
		}
		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 8:(callback)
	CompileCommandTokens [  3] type 4 comp 0 8:(callback)
	CompileCommandTokens [  4] type 2 comp 1 13:({method args})
	CompileCommandTokens [  5] type 4 comp 0 11:(method args)
	CompileCommandTokens [  6] type 2 comp 1 65:({
			list [uplevel 1 {::namespace which my}] $method {*}$args
		})
	CompileCommandTokens [  7] type 4 comp 0 63:(
			list [uplevel 1 {::namespace which my}] $method {*}$args
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1418: (		namespace export callback
		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 8:(callback)
	CompileCommandTokens [  5] type 4 comp 0 8:(callback)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1390: (		namespace eval tmp {namespace import ::oo::Helpers::callback}
		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 3:(tmp)
	CompileCommandTokens [  5] type 4 comp 0 3:(tmp)
	CompileCommandTokens [  6] type 2 comp 1 42:({namespace import ::oo::Helpers::callback})
	CompileCommandTokens [  7] type 4 comp 0 40:(namespace import ::oo::Helpers::callback)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1326: (		namespace export -clear
		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 6:(-clear)
	CompileCommandTokens [  5] type 4 comp 0 6:(-clear)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1300: (		rename tmp::callback mymethod
		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(rename)
	CompileCommandTokens [  1] type 4 comp 0 6:(rename)
	CompileCommandTokens [  2] type 2 comp 1 13:(tmp::callback)
	CompileCommandTokens [  3] type 4 comp 0 13:(tmp::callback)
	CompileCommandTokens [  4] type 2 comp 1 8:(mymethod)
	CompileCommandTokens [  5] type 4 comp 0 8:(mymethod)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1268: (		namespace delete tmp
		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(delete)
	CompileCommandTokens [  3] type 4 comp 0 6:(delete)
	CompileCommandTokens [  4] type 2 comp 1 3:(tmp)
	CompileCommandTokens [  5] type 4 comp 0 3:(tmp)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1245: (		proc classvariable {name args} {
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		}
		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 13:(classvariable)
	CompileCommandTokens [  3] type 4 comp 0 13:(classvariable)
	CompileCommandTokens [  4] type 2 comp 1 11:({name args})
	CompileCommandTokens [  5] type 4 comp 0 9:(name args)
	CompileCommandTokens [  6] type 2 comp 1 626:({
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		})
	CompileCommandTokens [  7] type 4 comp 0 624:(
			set ns [info object namespace [uplevel 1 {self class}]]
			foreach v [list $name {*}$args] {
				if {[string match *(*) $v]} {
					set reason "can't create a scalar variable that looks like an array element"
					return -code error -errorcode {TCL UPVAR LOCAL_ELEMENT}  [format {bad variable name "%s": %s} $v $reason]
				}
				if {[string match *::* $v]} {
					set reason "can't create a local variable with a namespace separator in it"
					return -code error -errorcode {TCL UPVAR INVERTED}  [format {bad variable name "%s": %s} $v $reason]
				}
				lappend vs $v $v
			}
			tailcall namespace upvar $ns {*}$vs
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 585: (		proc link {args} {
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 4:(link)
	CompileCommandTokens [  3] type 4 comp 0 4:(link)
	CompileCommandTokens [  4] type 2 comp 1 6:({args})
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 564:({
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		})
	CompileCommandTokens [  7] type 4 comp 0 562:(
			set ns [uplevel 1 {::namespace current}]
			foreach link $args {
				if {[llength $link] == 2} {
					lassign $link src dst
				} elseif {[llength $link] == 1} {
					lassign $link src
					set dst $src
				} else {
					return -code error -errorcode {TCLOO CMDLINK FORMAT}  "bad link description; must only have one or two elements"
				}
				if {![string match ::* $src]} {
					set src [string cat $ns :: $src]
				}
				interp alias {} $src {} ${ns}::my $dst
				trace add command ${ns}::my delete [list  ::oo::UnlinkLinkedCommand $src]
			}
			return
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38312c38
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::path'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 25: (namespace export callback)
	TclCompileScript parse 25: (namespace export callback)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 8:(callback)
	CompileCommandTokens [  5] type 4 comp 0 8:(callback)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38314498
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241040
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::export'
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 61: (namespace eval tmp {namespace import ::oo::Helpers::callback})
	TclCompileScript parse 61: (namespace eval tmp {namespace import ::oo::Helpers::callback})
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 3:(tmp)
	CompileCommandTokens [  5] type 4 comp 0 3:(tmp)
	CompileCommandTokens [  6] type 2 comp 1 42:({namespace import ::oo::Helpers::callback})
	CompileCommandTokens [  7] type 4 comp 0 40:(namespace import ::oo::Helpers::callback)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383146b8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241040
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 40: (namespace import ::oo::Helpers::callback)
	TclCompileScript parse 40: (namespace import ::oo::Helpers::callback)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(import)
	CompileCommandTokens [  3] type 4 comp 0 6:(import)
	CompileCommandTokens [  4] type 2 comp 1 23:(::oo::Helpers::callback)
	CompileCommandTokens [  5] type 4 comp 0 23:(::oo::Helpers::callback)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38314498
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241150
TEBCresume ip 0x558f3823dce8 td 0x558f38241150 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::import'
TEBCresume ip 0x558f3823dce8 td 0x558f38241150 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 23: (namespace export -clear)
	TclCompileScript parse 23: (namespace export -clear)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 6:(-clear)
	CompileCommandTokens [  5] type 4 comp 0 6:(-clear)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241040
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::export'
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'rename'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 20: (namespace delete tmp)
	TclCompileScript parse 20: (namespace delete tmp)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(delete)
	CompileCommandTokens [  3] type 4 comp 0 6:(delete)
	CompileCommandTokens [  4] type 2 comp 1 3:(tmp)
	CompileCommandTokens [  5] type 4 comp 0 3:(tmp)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241040
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::delete'
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240eb0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 218: (namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	})
	TclCompileScript parse 218: (namespace eval define {
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	})
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 6:(define)
	CompileCommandTokens [  5] type 4 comp 0 6:(define)
	CompileCommandTokens [  6] type 2 comp 1 196:({
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	})
	CompileCommandTokens [  7] type 4 comp 0 194:(
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3830eaa8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240eb0
TEBCresume ip 0x558f3823dce8 td 0x558f38240eb0 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 194: (
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	TclCompileScript parse 194: (
		::namespace export initialise
		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 10:(initialise)
	CompileCommandTokens [  5] type 4 comp 0 10:(initialise)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 161: (		::namespace eval tmp {::namespace import ::oo::define::initialise}
		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 3:(tmp)
	CompileCommandTokens [  5] type 4 comp 0 3:(tmp)
	CompileCommandTokens [  6] type 2 comp 1 45:({::namespace import ::oo::define::initialise})
	CompileCommandTokens [  7] type 4 comp 0 43:(::namespace import ::oo::define::initialise)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 92: (		::namespace export -clear
		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 6:(-clear)
	CompileCommandTokens [  5] type 4 comp 0 6:(-clear)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 64: (		::rename tmp::initialise initialize
		::namespace delete tmp
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(::rename)
	CompileCommandTokens [  1] type 4 comp 0 8:(::rename)
	CompileCommandTokens [  2] type 2 comp 1 15:(tmp::initialise)
	CompileCommandTokens [  3] type 4 comp 0 15:(tmp::initialise)
	CompileCommandTokens [  4] type 2 comp 1 10:(initialize)
	CompileCommandTokens [  5] type 4 comp 0 10:(initialize)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 26: (		::namespace delete tmp
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(delete)
	CompileCommandTokens [  3] type 4 comp 0 6:(delete)
	CompileCommandTokens [  4] type 2 comp 1 3:(tmp)
	CompileCommandTokens [  5] type 4 comp 0 3:(tmp)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f382c9b08
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::export'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 43: (::namespace import ::oo::define::initialise)
	TclCompileScript parse 43: (::namespace import ::oo::define::initialise)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 11:(::namespace)
	CompileCommandTokens [  1] type 4 comp 0 11:(::namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(import)
	CompileCommandTokens [  3] type 4 comp 0 6:(import)
	CompileCommandTokens [  4] type 2 comp 1 24:(::oo::define::initialise)
	CompileCommandTokens [  5] type 4 comp 0 24:(::oo::define::initialise)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831d598
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382410d0
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::import'
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::export'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::rename'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::delete'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240eb0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'define'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 1421: (
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse 1421: (
		method Get {} {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 3:(Get)
	CompileCommandTokens [  3] type 4 comp 0 3:(Get)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens [  6] type 2 comp 1 76:({
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		})
	CompileCommandTokens [  7] type 4 comp 0 74:(
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1327: (		method Set list {
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		}
		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 3:(Set)
	CompileCommandTokens [  3] type 4 comp 0 3:(Set)
	CompileCommandTokens [  4] type 2 comp 1 4:(list)
	CompileCommandTokens [  5] type 4 comp 0 4:(list)
	CompileCommandTokens [  6] type 2 comp 1 76:({
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		})
	CompileCommandTokens [  7] type 4 comp 0 74:(
			return -code error -errorcode {TCLOO ABSTRACT_SLOT} "unimplemented"
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1232: (		method Resolve list {
			return $list
		}
		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 7:(Resolve)
	CompileCommandTokens [  3] type 4 comp 0 7:(Resolve)
	CompileCommandTokens [  4] type 2 comp 1 4:(list)
	CompileCommandTokens [  5] type 4 comp 0 4:(list)
	CompileCommandTokens [  6] type 2 comp 1 21:({
			return $list
		})
	CompileCommandTokens [  7] type 4 comp 0 19:(
			return $list
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1188: (		method -set args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		}
		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 4:(-set)
	CompileCommandTokens [  3] type 4 comp 0 4:(-set)
	CompileCommandTokens [  4] type 2 comp 1 4:(args)
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 122:({
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		})
	CompileCommandTokens [  7] type 4 comp 0 120:(
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1046: (		method -append args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		}
		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 7:(-append)
	CompileCommandTokens [  3] type 4 comp 0 7:(-append)
	CompileCommandTokens [  4] type 2 comp 1 4:(args)
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 186:({
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		})
	CompileCommandTokens [  7] type 4 comp 0 184:(
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 837: (		method -clear {} {tailcall my Set {}}
		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 6:(-clear)
	CompileCommandTokens [  3] type 4 comp 0 6:(-clear)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens [  6] type 2 comp 1 20:({tailcall my Set {}})
	CompileCommandTokens [  7] type 4 comp 0 18:(tailcall my Set {})
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 797: (		method -prepend args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		}
		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 8:(-prepend)
	CompileCommandTokens [  3] type 4 comp 0 8:(-prepend)
	CompileCommandTokens [  4] type 2 comp 1 4:(args)
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 186:({
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		})
	CompileCommandTokens [  7] type 4 comp 0 184:(
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$args {*}$current]
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 587: (		method -remove args {
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		}
		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 7:(-remove)
	CompileCommandTokens [  3] type 4 comp 0 7:(-remove)
	CompileCommandTokens [  4] type 2 comp 1 4:(args)
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 232:({
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		})
	CompileCommandTokens [  7] type 4 comp 0 230:(
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [lmap val $current {
				if {$val in $args} continue else {set val}
			}]
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 332: (		forward --default-operation my -append
		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(forward)
	CompileCommandTokens [  1] type 4 comp 0 7:(forward)
	CompileCommandTokens [  2] type 2 comp 1 19:(--default-operation)
	CompileCommandTokens [  3] type 4 comp 0 19:(--default-operation)
	CompileCommandTokens [  4] type 2 comp 1 2:(my)
	CompileCommandTokens [  5] type 4 comp 0 2:(my)
	CompileCommandTokens [  6] type 2 comp 1 7:(-append)
	CompileCommandTokens [  7] type 4 comp 0 7:(-append)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 291: (		method unknown {args} {
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		}
		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 7:(unknown)
	CompileCommandTokens [  3] type 4 comp 0 7:(unknown)
	CompileCommandTokens [  4] type 2 comp 1 6:({args})
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 192:({
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		})
	CompileCommandTokens [  7] type 4 comp 0 190:(
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 74: (		export -set -append -clear -prepend -remove
		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 6:(export)
	CompileCommandTokens [  1] type 4 comp 0 6:(export)
	CompileCommandTokens [  2] type 2 comp 1 4:(-set)
	CompileCommandTokens [  3] type 4 comp 0 4:(-set)
	CompileCommandTokens [  4] type 2 comp 1 7:(-append)
	CompileCommandTokens [  5] type 4 comp 0 7:(-append)
	CompileCommandTokens [  6] type 2 comp 1 6:(-clear)
	CompileCommandTokens [  7] type 4 comp 0 6:(-clear)
	CompileCommandTokens [  8] type 2 comp 1 8:(-prepend)
	CompileCommandTokens [  9] type 4 comp 0 8:(-prepend)
	CompileCommandTokens [ 10] type 2 comp 1 7:(-remove)
	CompileCommandTokens [ 11] type 4 comp 0 7:(-remove)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 28: (		unexport unknown destroy
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(unexport)
	CompileCommandTokens [  1] type 4 comp 0 8:(unexport)
	CompileCommandTokens [  2] type 2 comp 1 7:(unknown)
	CompileCommandTokens [  3] type 4 comp 0 7:(unknown)
	CompileCommandTokens [  4] type 2 comp 1 7:(destroy)
	CompileCommandTokens [  5] type 4 comp 0 7:(destroy)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38320108
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240f30
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'forward'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'export'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'unexport'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f30 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::oo::objdefine::forward'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::oo::objdefine::forward'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::oo::objdefine::forward'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'define'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::oo::define::method'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'define'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::oo::define::method'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'class'
TclNRNewObjectInstance
TclInitRewriteEnsemble In  -3 +3 root 1
TclInitRewriteEnsemble Out -3 +3 root 1
TclNRNewObjectInstance push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::define'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 523: (
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	)
	TclCompileScript parse 523: (
		superclass class
		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 10:(superclass)
	CompileCommandTokens [  1] type 4 comp 0 10:(superclass)
	CompileCommandTokens [  2] type 2 comp 1 5:(class)
	CompileCommandTokens [  3] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 503: (		variable object
		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 8:(variable)
	CompileCommandTokens [  1] type 4 comp 0 8:(variable)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 485: (		unexport create createWithNamespace
		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(unexport)
	CompileCommandTokens [  1] type 4 comp 0 8:(unexport)
	CompileCommandTokens [  2] type 2 comp 1 6:(create)
	CompileCommandTokens [  3] type 4 comp 0 6:(create)
	CompileCommandTokens [  4] type 2 comp 1 19:(createWithNamespace)
	CompileCommandTokens [  5] type 4 comp 0 19:(createWithNamespace)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 447: (		method new args {
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 3:(new)
	CompileCommandTokens [  3] type 4 comp 0 3:(new)
	CompileCommandTokens [  4] type 2 comp 1 4:(args)
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 2 comp 1 427:({
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		})
	CompileCommandTokens [  7] type 4 comp 0 425:(
			if {![info exists object] || ![info object isa object $object]} {
				set object [next {*}$args]
				::oo::objdefine $object {
					method destroy {} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not destroy a singleton object"
					}
					method <cloned> {originObject} {
						::return -code error -errorcode {TCLOO SINGLETON}  "may not clone a singleton object"
					}
				}
			}
			return $object
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38328e68
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240f80
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'superclass'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 190: (
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 190: (
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(def)
	CompileCommandTokens [  3] type 4 comp 0 3:(def)
	CompileCommandTokens [  4] type 2 comp 1 19:(--default-operation)
	CompileCommandTokens [  5] type 4 comp 0 19:(--default-operation)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 158: (			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({[llength $args] == 0})
	CompileCommandTokens [  3] type 4 comp 0 20:([llength $args] == 0)
	CompileCommandTokens [  4] type 2 comp 1 27:({
				tailcall my $def
			})
	CompileCommandTokens [  5] type 4 comp 0 25:(
				tailcall my $def
			)
	CompileCommandTokens [  6] type 2 comp 1 6:(elseif)
	CompileCommandTokens [  7] type 4 comp 0 6:(elseif)
	CompileCommandTokens [  8] type 2 comp 1 37:({![string match -* [lindex $args 0]]})
	CompileCommandTokens [  9] type 4 comp 0 35:(![string match -* [lindex $args 0]])
	CompileCommandTokens [ 10] type 2 comp 1 36:({
				tailcall my $def {*}$args
			})
	CompileCommandTokens [ 11] type 4 comp 0 34:(
				tailcall my $def {*}$args
			)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 82 const 0 mark 0 (-2, -3)
	TclCompileScript 13: (llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 13: (llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 7:(llength)
	CompileCommandTokens [  1] type 4 comp 0 7:(llength)
	CompileCommandTokens [  2] type 1 comp 2 5:($args)
	CompileCommandTokens [  3] type 32 comp 1 5:($args)
	CompileCommandTokens [  4] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 82 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 25: (
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 25: (
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 2 4:($def)
	CompileCommandTokens [  5] type 32 comp 1 4:($def)
	CompileCommandTokens [  6] type 4 comp 0 3:(def)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3: (			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 32: (string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 32: (string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 5:(match)
	CompileCommandTokens [  3] type 4 comp 0 5:(match)
	CompileCommandTokens [  4] type 2 comp 1 2:(-*)
	CompileCommandTokens [  5] type 4 comp 0 2:(-*)
	CompileCommandTokens [  6] type 1 comp 1 16:([lindex $args 0])
	CompileCommandTokens [  7] type 16 comp 0 16:([lindex $args 0])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 14: (lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 14: (lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 6:(lindex)
	CompileCommandTokens [  1] type 4 comp 0 6:(lindex)
	CompileCommandTokens [  2] type 1 comp 2 5:($args)
	CompileCommandTokens [  3] type 32 comp 1 5:($args)
	CompileCommandTokens [  4] type 4 comp 0 4:(args)
	CompileCommandTokens [  5] type 2 comp 1 1:(0)
	CompileCommandTokens [  6] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 34: (
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 34: (
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 2 4:($def)
	CompileCommandTokens [  5] type 32 comp 1 4:($def)
	CompileCommandTokens [  6] type 4 comp 0 3:(def)
	CompileCommandTokens [  7] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  8] type 32 comp 1 5:($args)
	CompileCommandTokens [  9] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3: (			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 19: (			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 4:(next)
	CompileCommandTokens [  1] type 4 comp 0 4:(next)
	CompileCommandTokens [  2] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  3] type 32 comp 1 5:($args)
	CompileCommandTokens [  4] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832adb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382411b0
TEBCresume ip 0x558f3823dce8 td 0x558f382411b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'tailcall'
TEBCresume ip 0x558f3823dce8 td 0x558f382411b0 r 2
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
OOMethod/InitEnsembleRewrite In  -2 +2, oc 3 len 3
In  [ 0] 'my'
In  [ 1] '--default-operation'
In  [ 2] 'class'
Arg [ 0] 'my'
Arg [ 1] '-set'
Arg [ 2] 'class'
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
OOMethod/InitEnsembleRewrite push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 120: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 120: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 1 20:([namespace which my])
	CompileCommandTokens [  5] type 16 comp 0 20:([namespace which my])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 2:(my)
	CompileCommandTokens [  5] type 4 comp 0 2:(my)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 88: (			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(args)
	CompileCommandTokens [  3] type 4 comp 0 4:(args)
	CompileCommandTokens [  4] type 1 comp 1 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens [  5] type 16 comp 0 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(lmap)
	CompileCommandTokens [  1] type 4 comp 0 4:(lmap)
	CompileCommandTokens [  2] type 2 comp 1 1:(a)
	CompileCommandTokens [  3] type 4 comp 0 1:(a)
	CompileCommandTokens [  4] type 1 comp 2 5:($args)
	CompileCommandTokens [  5] type 32 comp 1 5:($args)
	CompileCommandTokens [  6] type 4 comp 0 4:(args)
	CompileCommandTokens [  7] type 2 comp 1 33:({uplevel 1 [list $my Resolve $a]})
	CompileCommandTokens [  8] type 4 comp 0 31:(uplevel 1 [list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 31: (uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 31: (uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 21:([list $my Resolve $a])
	CompileCommandTokens [  5] type 16 comp 0 21:([list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 19: (list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 19: (list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 3:($my)
	CompileCommandTokens [  3] type 32 comp 1 3:($my)
	CompileCommandTokens [  4] type 4 comp 0 2:(my)
	CompileCommandTokens [  5] type 2 comp 1 7:(Resolve)
	CompileCommandTokens [  6] type 4 comp 0 7:(Resolve)
	CompileCommandTokens [  7] type 1 comp 2 2:($a)
	CompileCommandTokens [  8] type 32 comp 1 2:($a)
	CompileCommandTokens [  9] type 4 comp 0 1:(a)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 27: (			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 2 comp 1 3:(Set)
	CompileCommandTokens [  5] type 4 comp 0 3:(Set)
	CompileCommandTokens [  6] type 1 comp 2 5:($args)
	CompileCommandTokens [  7] type 32 comp 1 5:($args)
	CompileCommandTokens [  8] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832e898
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241200
TEBCresume ip 0x558f3823dce8 td 0x558f38241200 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj6::my'
TEBCresume ip 0x558f3823dce8 td 0x558f38241200 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'variable'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832adb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382411b0
TEBCresume ip 0x558f3823dce8 td 0x558f382411b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'tailcall'
TEBCresume ip 0x558f3823dce8 td 0x558f382411b0 r 2
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
OOMethod/InitEnsembleRewrite In  -2 +2, oc 3 len 3
In  [ 0] 'my'
In  [ 1] '--default-operation'
In  [ 2] 'object'
Arg [ 0] 'my'
Arg [ 1] '-append'
Arg [ 2] 'object'
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
OOMethod/InitEnsembleRewrite push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 184: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 184: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 1 20:([namespace which my])
	CompileCommandTokens [  5] type 16 comp 0 20:([namespace which my])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 2:(my)
	CompileCommandTokens [  5] type 4 comp 0 2:(my)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 152: (			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(args)
	CompileCommandTokens [  3] type 4 comp 0 4:(args)
	CompileCommandTokens [  4] type 1 comp 1 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens [  5] type 16 comp 0 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(lmap)
	CompileCommandTokens [  1] type 4 comp 0 4:(lmap)
	CompileCommandTokens [  2] type 2 comp 1 1:(a)
	CompileCommandTokens [  3] type 4 comp 0 1:(a)
	CompileCommandTokens [  4] type 1 comp 2 5:($args)
	CompileCommandTokens [  5] type 32 comp 1 5:($args)
	CompileCommandTokens [  6] type 4 comp 0 4:(args)
	CompileCommandTokens [  7] type 2 comp 1 33:({uplevel 1 [list $my Resolve $a]})
	CompileCommandTokens [  8] type 4 comp 0 31:(uplevel 1 [list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 31: (uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 31: (uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 21:([list $my Resolve $a])
	CompileCommandTokens [  5] type 16 comp 0 21:([list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 19: (list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 19: (list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 3:($my)
	CompileCommandTokens [  3] type 32 comp 1 3:($my)
	CompileCommandTokens [  4] type 4 comp 0 2:(my)
	CompileCommandTokens [  5] type 2 comp 1 7:(Resolve)
	CompileCommandTokens [  6] type 4 comp 0 7:(Resolve)
	CompileCommandTokens [  7] type 1 comp 2 2:($a)
	CompileCommandTokens [  8] type 32 comp 1 2:($a)
	CompileCommandTokens [  9] type 4 comp 0 1:(a)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 91: (			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 7:(current)
	CompileCommandTokens [  3] type 4 comp 0 7:(current)
	CompileCommandTokens [  4] type 1 comp 1 26:([uplevel 1 [list $my Get]])
	CompileCommandTokens [  5] type 16 comp 0 26:([uplevel 1 [list $my Get]])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 24: (uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 24: (uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 14:([list $my Get])
	CompileCommandTokens [  5] type 16 comp 0 14:([list $my Get])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 12: (list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 12: (list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 3:($my)
	CompileCommandTokens [  3] type 32 comp 1 3:($my)
	CompileCommandTokens [  4] type 4 comp 0 2:(my)
	CompileCommandTokens [  5] type 2 comp 1 3:(Get)
	CompileCommandTokens [  6] type 4 comp 0 3:(Get)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 49: (			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 2 comp 1 3:(Set)
	CompileCommandTokens [  5] type 4 comp 0 3:(Set)
	CompileCommandTokens [  6] type 1 comp 1 27:([list {*}$current {*}$args])
	CompileCommandTokens [  7] type 16 comp 0 27:([list {*}$current {*}$args])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 25: (list {*}$current {*}$args]
		)
	TclCompileScript parse 25: (list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 256 comp 2 11:({*}$current)
	CompileCommandTokens [  3] type 32 comp 1 8:($current)
	CompileCommandTokens [  4] type 4 comp 0 7:(current)
	CompileCommandTokens [  5] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  6] type 32 comp 1 5:($args)
	CompileCommandTokens [  7] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38330cb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241210
TEBCresume ip 0x558f3823dce8 td 0x558f38241210 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj7::my'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 19: (
			return $list
		)
	TclCompileScript parse 19: (
			return $list
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens [  2] type 1 comp 2 5:($list)
	CompileCommandTokens [  3] type 32 comp 1 5:($list)
	CompileCommandTokens [  4] type 4 comp 0 4:(list)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 19: (
			return $list
		)
	TclCompileScript parse 19: (
			return $list
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens [  2] type 1 comp 2 5:($list)
	CompileCommandTokens [  3] type 32 comp 1 5:($list)
	CompileCommandTokens [  4] type 4 comp 0 4:(list)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38333288
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382414c0
TEBCresume ip 0x558f3823dce8 td 0x558f382414c0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241210 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::Obj7::my'
TEBCresume ip 0x558f3823dce8 td 0x558f38241210 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'unexport'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::MixinClassDelegates'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 400: (
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 400: (
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 33:({![info object isa class $class]})
	CompileCommandTokens [  3] type 4 comp 0 31:(![info object isa class $class])
	CompileCommandTokens [  4] type 2 comp 1 15:({
			return
		})
	CompileCommandTokens [  5] type 4 comp 0 13:(
			return
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 28: (info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 28: (info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 6:($class)
	CompileCommandTokens [  9] type 32 comp 1 6:($class)
	CompileCommandTokens [ 10] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 13: (
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 13: (
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 344: (		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 8:(delegate)
	CompileCommandTokens [  3] type 4 comp 0 8:(delegate)
	CompileCommandTokens [  4] type 1 comp 1 21:([DelegateName $class])
	CompileCommandTokens [  5] type 16 comp 0 21:([DelegateName $class])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 19: (DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 19: (DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 12:(DelegateName)
	CompileCommandTokens [  1] type 4 comp 0 12:(DelegateName)
	CompileCommandTokens [  2] type 1 comp 2 6:($class)
	CompileCommandTokens [  3] type 32 comp 1 6:($class)
	CompileCommandTokens [  4] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 307: (		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 36:({![info object isa class $delegate]})
	CompileCommandTokens [  3] type 4 comp 0 34:(![info object isa class $delegate])
	CompileCommandTokens [  4] type 2 comp 1 15:({
			return
		})
	CompileCommandTokens [  5] type 4 comp 0 13:(
			return
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 31: (info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 31: (info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 9:($delegate)
	CompileCommandTokens [  9] type 32 comp 1 9:($delegate)
	CompileCommandTokens [ 10] type 4 comp 0 8:(delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 13: (
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 13: (
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 249: (		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 1:(c)
	CompileCommandTokens [  3] type 4 comp 0 1:(c)
	CompileCommandTokens [  4] type 1 comp 1 30:([info class superclass $class])
	CompileCommandTokens [  5] type 16 comp 0 30:([info class superclass $class])
	CompileCommandTokens [  6] type 2 comp 1 144:({
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		})
	CompileCommandTokens [  7] type 4 comp 0 142:(
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 28: (info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 5:(class)
	CompileCommandTokens [  3] type 4 comp 0 5:(class)
	CompileCommandTokens [  4] type 2 comp 1 10:(superclass)
	CompileCommandTokens [  5] type 4 comp 0 10:(superclass)
	CompileCommandTokens [  6] type 1 comp 2 6:($class)
	CompileCommandTokens [  7] type 32 comp 1 6:($class)
	CompileCommandTokens [  8] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 142: (
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 142: (
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 1:(d)
	CompileCommandTokens [  3] type 4 comp 0 1:(d)
	CompileCommandTokens [  4] type 1 comp 1 17:([DelegateName $c])
	CompileCommandTokens [  5] type 16 comp 0 17:([DelegateName $c])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 15: (DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 15: (DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 12:(DelegateName)
	CompileCommandTokens [  1] type 4 comp 0 12:(DelegateName)
	CompileCommandTokens [  2] type 1 comp 2 2:($c)
	CompileCommandTokens [  3] type 32 comp 1 2:($c)
	CompileCommandTokens [  4] type 4 comp 0 1:(c)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 114: (			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 29:({![info object isa class $d]})
	CompileCommandTokens [  3] type 4 comp 0 27:(![info object isa class $d])
	CompileCommandTokens [  4] type 2 comp 1 19:({
				continue
			})
	CompileCommandTokens [  5] type 4 comp 0 17:(
				continue
			)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 24: (info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 24: (info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 2:($d)
	CompileCommandTokens [  9] type 32 comp 1 2:($d)
	CompileCommandTokens [ 10] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 17: (
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 17: (
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 8:(continue)
	CompileCommandTokens [  1] type 4 comp 0 8:(continue)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3: (			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 58: (			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 6:(define)
	CompileCommandTokens [  1] type 4 comp 0 6:(define)
	CompileCommandTokens [  2] type 1 comp 2 9:($delegate)
	CompileCommandTokens [  3] type 32 comp 1 9:($delegate)
	CompileCommandTokens [  4] type 4 comp 0 8:(delegate)
	CompileCommandTokens [  5] type 2 comp 1 24:(::oo::define::superclass)
	CompileCommandTokens [  6] type 4 comp 0 24:(::oo::define::superclass)
	CompileCommandTokens [  7] type 2 comp 1 7:(-append)
	CompileCommandTokens [  8] type 4 comp 0 7:(-append)
	CompileCommandTokens [  9] type 1 comp 2 2:($d)
	CompileCommandTokens [ 10] type 32 comp 1 2:($d)
	CompileCommandTokens [ 11] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 61: (		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 9:(objdefine)
	CompileCommandTokens [  1] type 4 comp 0 9:(objdefine)
	CompileCommandTokens [  2] type 1 comp 2 6:($class)
	CompileCommandTokens [  3] type 32 comp 1 6:($class)
	CompileCommandTokens [  4] type 4 comp 0 5:(class)
	CompileCommandTokens [  5] type 2 comp 1 22:(::oo::objdefine::mixin)
	CompileCommandTokens [  6] type 4 comp 0 22:(::oo::objdefine::mixin)
	CompileCommandTokens [  7] type 2 comp 1 7:(-append)
	CompileCommandTokens [  8] type 4 comp 0 7:(-append)
	CompileCommandTokens [  9] type 1 comp 2 9:($delegate)
	CompileCommandTokens [ 10] type 32 comp 1 9:($delegate)
	CompileCommandTokens [ 11] type 4 comp 0 8:(delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38334a08
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fd0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 3:(cat)
	CompileCommandTokens [  3] type 4 comp 0 3:(cat)
	CompileCommandTokens [  4] type 1 comp 1 30:([info object namespace $class])
	CompileCommandTokens [  5] type 16 comp 0 30:([info object namespace $class])
	CompileCommandTokens [  6] type 2 comp 1 18:({:: oo ::delegate})
	CompileCommandTokens [  7] type 4 comp 0 16:(:: oo ::delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  5] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  6] type 1 comp 2 6:($class)
	CompileCommandTokens [  7] type 32 comp 1 6:($class)
	CompileCommandTokens [  8] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 3:(cat)
	CompileCommandTokens [  3] type 4 comp 0 3:(cat)
	CompileCommandTokens [  4] type 1 comp 1 30:([info object namespace $class])
	CompileCommandTokens [  5] type 16 comp 0 30:([info object namespace $class])
	CompileCommandTokens [  6] type 2 comp 1 18:({:: oo ::delegate})
	CompileCommandTokens [  7] type 4 comp 0 16:(:: oo ::delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  5] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  6] type 1 comp 2 6:($class)
	CompileCommandTokens [  7] type 32 comp 1 6:($class)
	CompileCommandTokens [  8] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241100
TEBCresume ip 0x558f3823dce8 td 0x558f38241100 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::InfoClass::superclasses'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241110
TEBCresume ip 0x558f3823dce8 td 0x558f38241110 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::objdefine::mixin'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38330cb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382412b0
TEBCresume ip 0x558f3823dce8 td 0x558f382412b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382412b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382412b0 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'class'
TclNRNewObjectInstance
TclInitRewriteEnsemble In  -3 +3 root 1
TclInitRewriteEnsemble Out -3 +3 root 1
TclNRNewObjectInstance push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::define'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 63: (
		superclass class
		unexport create createWithNamespace new
	)
	TclCompileScript parse 63: (
		superclass class
		unexport create createWithNamespace new
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 10:(superclass)
	CompileCommandTokens [  1] type 4 comp 0 10:(superclass)
	CompileCommandTokens [  2] type 2 comp 1 5:(class)
	CompileCommandTokens [  3] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 43: (		unexport create createWithNamespace new
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 8:(unexport)
	CompileCommandTokens [  1] type 4 comp 0 8:(unexport)
	CompileCommandTokens [  2] type 2 comp 1 6:(create)
	CompileCommandTokens [  3] type 4 comp 0 6:(create)
	CompileCommandTokens [  4] type 2 comp 1 19:(createWithNamespace)
	CompileCommandTokens [  5] type 4 comp 0 19:(createWithNamespace)
	CompileCommandTokens [  6] type 2 comp 1 3:(new)
	CompileCommandTokens [  7] type 4 comp 0 3:(new)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3830eaa8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240f80
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'superclass'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832adb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382411b0
TEBCresume ip 0x558f3823dce8 td 0x558f382411b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'tailcall'
TEBCresume ip 0x558f3823dce8 td 0x558f382411b0 r 2
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
OOMethod/InitEnsembleRewrite In  -2 +2, oc 3 len 3
In  [ 0] 'my'
In  [ 1] '--default-operation'
In  [ 2] 'class'
Arg [ 0] 'my'
Arg [ 1] '-set'
Arg [ 2] 'class'
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
OOMethod/InitEnsembleRewrite push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832e898
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241200
TEBCresume ip 0x558f3823dce8 td 0x558f38241200 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj6::my'
TEBCresume ip 0x558f3823dce8 td 0x558f38241200 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'unexport'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f80 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::MixinClassDelegates'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38334a08
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fd0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241100
TEBCresume ip 0x558f3823dce8 td 0x558f38241100 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::InfoClass::superclasses'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241110
TEBCresume ip 0x558f3823dce8 td 0x558f38241110 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::objdefine::mixin'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38330cb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382412b0
TEBCresume ip 0x558f3823dce8 td 0x558f382412b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382412b0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382412b0 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fd0 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'package'
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'package'
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'namespace'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 24: ( variable version 1.2.0 )
	TclCompileScript parse 24: ( variable version 1.2.0 )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(variable)
	CompileCommandTokens [  1] type 4 comp 0 8:(variable)
	CompileCommandTokens [  2] type 2 comp 1 7:(version)
	CompileCommandTokens [  3] type 4 comp 0 7:(version)
	CompileCommandTokens [  4] type 2 comp 1 5:(1.2.0)
	CompileCommandTokens [  5] type 4 comp 0 5:(1.2.0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831e878
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e30
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'variable'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'namespace'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 27: ( variable patchlevel 1.2.0 )
	TclCompileScript parse 27: ( variable patchlevel 1.2.0 )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(variable)
	CompileCommandTokens [  1] type 4 comp 0 8:(variable)
	CompileCommandTokens [  2] type 2 comp 1 10:(patchlevel)
	CompileCommandTokens [  3] type 4 comp 0 10:(patchlevel)
	CompileCommandTokens [  4] type 2 comp 1 5:(1.2.0)
	CompileCommandTokens [  5] type 4 comp 0 5:(1.2.0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831e878
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e30
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'variable'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'namespace'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 21: (variable cmdcounter 0)
	TclCompileScript parse 21: (variable cmdcounter 0)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(variable)
	CompileCommandTokens [  1] type 4 comp 0 8:(variable)
	CompileCommandTokens [  2] type 2 comp 1 10:(cmdcounter)
	CompileCommandTokens [  3] type 4 comp 0 10:(cmdcounter)
	CompileCommandTokens [  4] type 2 comp 1 1:(0)
	CompileCommandTokens [  5] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831e878
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e30
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'variable'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'namespace'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 0: ()
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 0: ()
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38309238
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e30
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'if'
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 86 const 0 mark 0 (-2, -3)
	TclCompileScript 32: (namespace which -command tclInit] eq "")
	TclCompileScript parse 32: (namespace which -command tclInit] eq "")
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 8:(-command)
	CompileCommandTokens [  5] type 4 comp 0 8:(-command)
	CompileCommandTokens [  6] type 2 comp 1 7:(tclInit)
	CompileCommandTokens [  7] type 4 comp 0 7:(tclInit)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38314498
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240dc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240dc0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 2104: (
  proc tclInit {} {
    global tcl_libPath tcl_library env tclDefaultLibrary
    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  }
)
	TclCompileScript parse 2104: (
  proc tclInit {} {
    global tcl_libPath tcl_library env tclDefaultLibrary
    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 7:(tclInit)
	CompileCommandTokens [  3] type 4 comp 0 7:(tclInit)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens [  6] type 2 comp 1 2084:({
    global tcl_libPath tcl_library env tclDefaultLibrary
    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  })
	CompileCommandTokens [  7] type 4 comp 0 2082:(
    global tcl_libPath tcl_library env tclDefaultLibrary
    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3823d998
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240dc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240dc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38240dc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd 'tclInit'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 2082: (
    global tcl_libPath tcl_library env tclDefaultLibrary
    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 2082: (
    global tcl_libPath tcl_library env tclDefaultLibrary
    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 6:(global)
	CompileCommandTokens [  1] type 4 comp 0 6:(global)
	CompileCommandTokens [  2] type 2 comp 1 11:(tcl_libPath)
	CompileCommandTokens [  3] type 4 comp 0 11:(tcl_libPath)
	CompileCommandTokens [  4] type 2 comp 1 11:(tcl_library)
	CompileCommandTokens [  5] type 4 comp 0 11:(tcl_library)
	CompileCommandTokens [  6] type 2 comp 1 3:(env)
	CompileCommandTokens [  7] type 4 comp 0 3:(env)
	CompileCommandTokens [  8] type 2 comp 1 17:(tclDefaultLibrary)
	CompileCommandTokens [  9] type 4 comp 0 17:(tclDefaultLibrary)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2024: (    rename tclInit {}
    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(rename)
	CompileCommandTokens [  1] type 4 comp 0 6:(rename)
	CompileCommandTokens [  2] type 2 comp 1 7:(tclInit)
	CompileCommandTokens [  3] type 4 comp 0 7:(tclInit)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2002: (    if {[info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 27:({[info exists tcl_library]})
	CompileCommandTokens [  3] type 4 comp 0 25:([info exists tcl_library])
	CompileCommandTokens [  4] type 2 comp 1 40:({
	set scripts {{set tcl_library}}
    })
	CompileCommandTokens [  5] type 4 comp 0 38:(
	set scripts {{set tcl_library}}
    )
	CompileCommandTokens [  6] type 2 comp 1 4:(else)
	CompileCommandTokens [  7] type 4 comp 0 4:(else)
	CompileCommandTokens [  8] type 2 comp 1 1225:({
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    })
	CompileCommandTokens [  9] type 4 comp 0 1223:(
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 23: (info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 23: (info exists tcl_library]} {
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 11:(tcl_library)
	CompileCommandTokens [  5] type 4 comp 0 11:(tcl_library)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
	TclCompileScript 38: (
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 38: (
	set scripts {{set tcl_library}}
    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 19:({{set tcl_library}})
	CompileCommandTokens [  5] type 4 comp 0 17:({set tcl_library})
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    } else {
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 1223: (
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 1223: (
	set scripts {}
	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1206: (	if {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 61:({[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})})
	CompileCommandTokens [  3] type 4 comp 0 59:([info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {}))
	CompileCommandTokens [  4] type 2 comp 1 253:({
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	})
	CompileCommandTokens [  5] type 4 comp 0 251:(
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 84 const 0 mark 0 (-2, 2)
	TclCompileScript 28: (info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 28: (info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 16:(env(TCL_LIBRARY))
	CompileCommandTokens [  5] type 4 comp 0 16:(env(TCL_LIBRARY))
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 1 (-2, 2)
CompileExprTree Processing @2 (lex 133 const 0 mark 1 (1633771873, 3)
CompileExprTree Processing @3 (lex 87 const 0 mark 0 (-2, -3)
CompileExprTree Processing @3 (lex 87 const 0 mark 1 (-2, -3)
CompileExprTree Processing @3 (lex 87 const 0 mark 2 (-2, -3)
CompileExprTree Processing @2 (lex 133 const 0 mark 2 (1633771873, 3)
CompileExprTree Processing @1 (lex 84 const 0 mark 2 (-2, 2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 251: (
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 251: (
	    lappend scripts {set env(TCL_LIBRARY)}
	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 22:({set env(TCL_LIBRARY)})
	CompileCommandTokens [  5] type 4 comp 0 20:(set env(TCL_LIBRARY))
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 206: (	    lappend scripts {
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}
	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 183:({
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]})
	CompileCommandTokens [  5] type 4 comp 0 181:(
if {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue
if {$tail eq [info tclversion]} continue
file join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}
	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 886: (	if {[info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 33:({[info exists tclDefaultLibrary]})
	CompileCommandTokens [  3] type 4 comp 0 31:([info exists tclDefaultLibrary])
	CompileCommandTokens [  4] type 2 comp 1 49:({
	    lappend scripts {set tclDefaultLibrary}
	})
	CompileCommandTokens [  5] type 4 comp 0 47:(
	    lappend scripts {set tclDefaultLibrary}
	)
	CompileCommandTokens [  6] type 2 comp 1 4:(else)
	CompileCommandTokens [  7] type 4 comp 0 4:(else)
	CompileCommandTokens [  8] type 2 comp 1 66:({
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	})
	CompileCommandTokens [  9] type 4 comp 0 64:(
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 29: (info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 29: (info exists tclDefaultLibrary]} {
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 17:(tclDefaultLibrary)
	CompileCommandTokens [  5] type 4 comp 0 17:(tclDefaultLibrary)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
	TclCompileScript 47: (
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 47: (
	    lappend scripts {set tclDefaultLibrary}
	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 23:({set tclDefaultLibrary})
	CompileCommandTokens [  5] type 4 comp 0 21:(set tclDefaultLibrary)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	} else {
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 64: (
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 64: (
	    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}
	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 40:({::tcl::pkgconfig get scriptdir,runtime})
	CompileCommandTokens [  5] type 4 comp 0 38:(::tcl::pkgconfig get scriptdir,runtime)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}
	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 726: (	lappend scripts {::tcl::zipfs::tcl_library_init}
	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 32:({::tcl::zipfs::tcl_library_init})
	CompileCommandTokens [  5] type 4 comp 0 30:(::tcl::zipfs::tcl_library_init)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 676: (	lappend scripts {
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]}  {file join $grandParentDir lib tcl[info tclversion]}  {file join $parentDir library}  {file join $grandParentDir library}  {file join $grandParentDir tcl[info tclversion] library}  {file join $grandParentDir tcl[info patchlevel] library}  {
file join [file dirname $grandParentDir] tcl[info patchlevel] library}
	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 9 tokens 18
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 2 comp 1 161:({
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion]})
	CompileCommandTokens [  5] type 4 comp 0 159:(
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
file join $parentDir lib tcl[info tclversion])
	CompileCommandTokens [  6] type 2 comp 1 52:({file join $grandParentDir lib tcl[info tclversion]})
	CompileCommandTokens [  7] type 4 comp 0 50:(file join $grandParentDir lib tcl[info tclversion])
	CompileCommandTokens [  8] type 2 comp 1 30:({file join $parentDir library})
	CompileCommandTokens [  9] type 4 comp 0 28:(file join $parentDir library)
	CompileCommandTokens [ 10] type 2 comp 1 35:({file join $grandParentDir library})
	CompileCommandTokens [ 11] type 4 comp 0 33:(file join $grandParentDir library)
	CompileCommandTokens [ 12] type 2 comp 1 56:({file join $grandParentDir tcl[info tclversion] library})
	CompileCommandTokens [ 13] type 4 comp 0 54:(file join $grandParentDir tcl[info tclversion] library)
	CompileCommandTokens [ 14] type 2 comp 1 56:({file join $grandParentDir tcl[info patchlevel] library})
	CompileCommandTokens [ 15] type 4 comp 0 54:(file join $grandParentDir tcl[info patchlevel] library)
	CompileCommandTokens [ 16] type 2 comp 1 72:({
file join [file dirname $grandParentDir] tcl[info patchlevel] library})
	CompileCommandTokens [ 17] type 4 comp 0 70:(
file join [file dirname $grandParentDir] tcl[info patchlevel] library)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 184: (	if {[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 72:({[info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0})
	CompileCommandTokens [  3] type 4 comp 0 70:([info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0)
	CompileCommandTokens [  4] type 2 comp 1 102:({
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	})
	CompileCommandTokens [  5] type 4 comp 0 100:(
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 84 const 0 mark 0 (-2, 2)
	TclCompileScript 23: (info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 23: (info exists tcl_libPath]
		&& [catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 11:(tcl_libPath)
	CompileCommandTokens [  5] type 4 comp 0 11:(tcl_libPath)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 1 (-2, 2)
CompileExprTree Processing @2 (lex 82 const 0 mark 0 (-2, -3)
	TclCompileScript 32: (catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 32: (catch {llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 5:(catch)
	CompileCommandTokens [  1] type 4 comp 0 5:(catch)
	CompileCommandTokens [  2] type 2 comp 1 22:({llength $tcl_libPath})
	CompileCommandTokens [  3] type 4 comp 0 20:(llength $tcl_libPath)
	CompileCommandTokens [  4] type 2 comp 1 3:(len)
	CompileCommandTokens [  5] type 4 comp 0 3:(len)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 20: (llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 20: (llength $tcl_libPath} len] == 0} {
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 7:(llength)
	CompileCommandTokens [  1] type 4 comp 0 7:(llength)
	CompileCommandTokens [  2] type 1 comp 2 12:($tcl_libPath)
	CompileCommandTokens [  3] type 32 comp 1 12:($tcl_libPath)
	CompileCommandTokens [  4] type 4 comp 0 11:(tcl_libPath)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @2 (lex 82 const 0 mark 1 (-2, -3)
CompileExprTree Processing @2 (lex 82 const 0 mark 2 (-2, -3)
CompileExprTree Processing @1 (lex 84 const 0 mark 2 (-2, 2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 100: (
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 100: (
	    for {set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 3:(for)
	CompileCommandTokens [  1] type 4 comp 0 3:(for)
	CompileCommandTokens [  2] type 2 comp 1 9:({set i 0})
	CompileCommandTokens [  3] type 4 comp 0 7:(set i 0)
	CompileCommandTokens [  4] type 2 comp 1 11:({$i < $len})
	CompileCommandTokens [  5] type 4 comp 0 9:($i < $len)
	CompileCommandTokens [  6] type 2 comp 1 8:({incr i})
	CompileCommandTokens [  7] type 4 comp 0 6:(incr i)
	CompileCommandTokens [  8] type 2 comp 1 57:({
		lappend scripts [list lindex \$tcl_libPath $i]
	    })
	CompileCommandTokens [  9] type 4 comp 0 55:(
		lappend scripts [list lindex \$tcl_libPath $i]
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 7: (set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 7: (set i 0} {$i < $len} {incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 1:(i)
	CompileCommandTokens [  3] type 4 comp 0 1:(i)
	CompileCommandTokens [  4] type 2 comp 1 1:(0)
	CompileCommandTokens [  5] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 55: (
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 55: (
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 7:(scripts)
	CompileCommandTokens [  3] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  4] type 1 comp 1 30:([list lindex \$tcl_libPath $i])
	CompileCommandTokens [  5] type 16 comp 0 30:([list lindex \$tcl_libPath $i])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 28: (list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 2 comp 1 6:(lindex)
	CompileCommandTokens [  3] type 4 comp 0 6:(lindex)
	CompileCommandTokens [  4] type 1 comp 2 13:(\$tcl_libPath)
	CompileCommandTokens [  5] type 8 comp 0 2:(\$)
	CompileCommandTokens [  6] type 4 comp 0 11:(tcl_libPath)
	CompileCommandTokens [  7] type 1 comp 2 2:($i)
	CompileCommandTokens [  8] type 32 comp 1 2:($i)
	CompileCommandTokens [  9] type 4 comp 0 1:(i)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5: (	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 6: (incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 6: (incr i} {
		lappend scripts [list lindex \$tcl_libPath $i]
	    }
	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 4:(incr)
	CompileCommandTokens [  1] type 4 comp 0 4:(incr)
	CompileCommandTokens [  2] type 2 comp 1 1:(i)
	CompileCommandTokens [  3] type 4 comp 0 1:(i)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 71 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 71 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 71 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}
    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }
    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 695: (    set dirs {}
    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(dirs)
	CompileCommandTokens [  3] type 4 comp 0 4:(dirs)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 679: (    set errors {}
    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 6:(errors)
	CompileCommandTokens [  3] type 4 comp 0 6:(errors)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 661: (    foreach script $scripts {
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 6:(script)
	CompileCommandTokens [  3] type 4 comp 0 6:(script)
	CompileCommandTokens [  4] type 1 comp 2 8:($scripts)
	CompileCommandTokens [  5] type 32 comp 1 8:($scripts)
	CompileCommandTokens [  6] type 4 comp 0 7:(scripts)
	CompileCommandTokens [  7] type 2 comp 1 370:({
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    })
	CompileCommandTokens [  8] type 4 comp 0 368:(
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 368: (
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 368: (
	lappend dirs [eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 4:(dirs)
	CompileCommandTokens [  3] type 4 comp 0 4:(dirs)
	CompileCommandTokens [  4] type 1 comp 1 14:([eval $script])
	CompileCommandTokens [  5] type 16 comp 0 14:([eval $script])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 12: (eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 12: (eval $script]
	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 4:(eval)
	CompileCommandTokens [  1] type 4 comp 0 4:(eval)
	CompileCommandTokens [  2] type 1 comp 2 7:($script)
	CompileCommandTokens [  3] type 32 comp 1 7:($script)
	CompileCommandTokens [  4] type 4 comp 0 6:(script)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 338: (	set tcl_library [lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 11:(tcl_library)
	CompileCommandTokens [  3] type 4 comp 0 11:(tcl_library)
	CompileCommandTokens [  4] type 1 comp 1 18:([lindex $dirs end])
	CompileCommandTokens [  5] type 16 comp 0 18:([lindex $dirs end])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 16: (lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 16: (lindex $dirs end]
	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 6:(lindex)
	CompileCommandTokens [  1] type 4 comp 0 6:(lindex)
	CompileCommandTokens [  2] type 1 comp 2 5:($dirs)
	CompileCommandTokens [  3] type 32 comp 1 5:($dirs)
	CompileCommandTokens [  4] type 4 comp 0 4:(dirs)
	CompileCommandTokens [  5] type 2 comp 1 3:(end)
	CompileCommandTokens [  6] type 4 comp 0 3:(end)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 302: (	set tclfile [file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 7:(tclfile)
	CompileCommandTokens [  3] type 4 comp 0 7:(tclfile)
	CompileCommandTokens [  4] type 1 comp 1 33:([file join $tcl_library init.tcl])
	CompileCommandTokens [  5] type 16 comp 0 33:([file join $tcl_library init.tcl])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 31: (file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 31: (file join $tcl_library init.tcl]
	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 4:(join)
	CompileCommandTokens [  3] type 4 comp 0 4:(join)
	CompileCommandTokens [  4] type 1 comp 2 12:($tcl_library)
	CompileCommandTokens [  5] type 32 comp 1 12:($tcl_library)
	CompileCommandTokens [  6] type 4 comp 0 11:(tcl_library)
	CompileCommandTokens [  7] type 2 comp 1 8:(init.tcl)
	CompileCommandTokens [  8] type 4 comp 0 8:(init.tcl)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 255: (	if {[file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 24:({[file exists $tclfile]})
	CompileCommandTokens [  3] type 4 comp 0 22:([file exists $tclfile])
	CompileCommandTokens [  4] type 2 comp 1 221:({
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	})
	CompileCommandTokens [  5] type 4 comp 0 219:(
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 20: (file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 20: (file exists $tclfile]} {
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 1 comp 2 8:($tclfile)
	CompileCommandTokens [  5] type 32 comp 1 8:($tclfile)
	CompileCommandTokens [  6] type 4 comp 0 7:(tclfile)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
	TclCompileScript 219: (
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 219: (
	    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 54:({[catch {uplevel #0 [list source $tclfile]} msg opts]})
	CompileCommandTokens [  3] type 4 comp 0 52:([catch {uplevel #0 [list source $tclfile]} msg opts])
	CompileCommandTokens [  4] type 2 comp 1 100:({
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    })
	CompileCommandTokens [  5] type 4 comp 0 98:(
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 50: (catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 50: (catch {uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 5:(catch)
	CompileCommandTokens [  1] type 4 comp 0 5:(catch)
	CompileCommandTokens [  2] type 2 comp 1 35:({uplevel #0 [list source $tclfile]})
	CompileCommandTokens [  3] type 4 comp 0 33:(uplevel #0 [list source $tclfile])
	CompileCommandTokens [  4] type 2 comp 1 3:(msg)
	CompileCommandTokens [  5] type 4 comp 0 3:(msg)
	CompileCommandTokens [  6] type 2 comp 1 4:(opts)
	CompileCommandTokens [  7] type 4 comp 0 4:(opts)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 33: (uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 33: (uplevel #0 [list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 2:(#0)
	CompileCommandTokens [  3] type 4 comp 0 2:(#0)
	CompileCommandTokens [  4] type 1 comp 1 22:([list source $tclfile])
	CompileCommandTokens [  5] type 16 comp 0 22:([list source $tclfile])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 20: (list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 20: (list source $tclfile]} msg opts]} {
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 2 comp 1 6:(source)
	CompileCommandTokens [  3] type 4 comp 0 6:(source)
	CompileCommandTokens [  4] type 1 comp 2 8:($tclfile)
	CompileCommandTokens [  5] type 32 comp 1 8:($tclfile)
	CompileCommandTokens [  6] type 4 comp 0 7:(tclfile)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
	TclCompileScript 98: (
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 98: (
		append errors "$tclfile: $msg
"
		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 6:(append)
	CompileCommandTokens [  1] type 4 comp 0 6:(append)
	CompileCommandTokens [  2] type 2 comp 1 6:(errors)
	CompileCommandTokens [  3] type 4 comp 0 6:(errors)
	CompileCommandTokens [  4] type 1 comp 6 17:("$tclfile: $msg
")
	CompileCommandTokens [  5] type 32 comp 1 8:($tclfile)
	CompileCommandTokens [  6] type 4 comp 0 7:(tclfile)
	CompileCommandTokens [  7] type 4 comp 0 2:(: )
	CompileCommandTokens [  8] type 32 comp 1 4:($msg)
	CompileCommandTokens [  9] type 4 comp 0 3:(msg)
	CompileCommandTokens [ 10] type 4 comp 0 1:(
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 63: (		append errors "[dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 6:(append)
	CompileCommandTokens [  1] type 4 comp 0 6:(append)
	CompileCommandTokens [  2] type 2 comp 1 6:(errors)
	CompileCommandTokens [  3] type 4 comp 0 6:(errors)
	CompileCommandTokens [  4] type 1 comp 2 30:("[dict get $opts -errorinfo]
")
	CompileCommandTokens [  5] type 16 comp 0 27:([dict get $opts -errorinfo])
	CompileCommandTokens [  6] type 4 comp 0 1:(
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 25: (dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse 25: (dict get $opts -errorinfo]
"
		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(dict)
	CompileCommandTokens [  1] type 4 comp 0 4:(dict)
	CompileCommandTokens [  2] type 2 comp 1 3:(get)
	CompileCommandTokens [  3] type 4 comp 0 3:(get)
	CompileCommandTokens [  4] type 1 comp 2 5:($opts)
	CompileCommandTokens [  5] type 32 comp 1 5:($opts)
	CompileCommandTokens [  6] type 4 comp 0 4:(opts)
	CompileCommandTokens [  7] type 2 comp 1 10:(-errorinfo)
	CompileCommandTokens [  8] type 4 comp 0 10:(-errorinfo)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 16: (		continue
	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 8:(continue)
	CompileCommandTokens [  1] type 4 comp 0 8:(continue)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5: (	    }
	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 54: (	    unset -nocomplain tclDefaultLibrary
	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 5:(unset)
	CompileCommandTokens [  1] type 4 comp 0 5:(unset)
	CompileCommandTokens [  2] type 2 comp 1 11:(-nocomplain)
	CompileCommandTokens [  3] type 4 comp 0 11:(-nocomplain)
	CompileCommandTokens [  4] type 2 comp 1 17:(tclDefaultLibrary)
	CompileCommandTokens [  5] type 4 comp 0 17:(tclDefaultLibrary)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 13: (	    return
	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}
    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }
    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 262: (    unset -nocomplain tclDefaultLibrary
    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 5:(unset)
	CompileCommandTokens [  1] type 4 comp 0 5:(unset)
	CompileCommandTokens [  2] type 2 comp 1 11:(-nocomplain)
	CompileCommandTokens [  3] type 4 comp 0 11:(-nocomplain)
	CompileCommandTokens [  4] type 2 comp 1 17:(tclDefaultLibrary)
	CompileCommandTokens [  5] type 4 comp 0 17:(tclDefaultLibrary)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 222: (    set msg "Can't find a usable init.tcl in the following directories: 
"
    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(msg)
	CompileCommandTokens [  3] type 4 comp 0 3:(msg)
	CompileCommandTokens [  4] type 2 comp 1 62:("Can't find a usable init.tcl in the following directories: 
")
	CompileCommandTokens [  5] type 4 comp 0 60:(Can't find a usable init.tcl in the following directories: 
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 147: (    append msg "    $dirs

"
    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 6:(append)
	CompileCommandTokens [  1] type 4 comp 0 6:(append)
	CompileCommandTokens [  2] type 2 comp 1 3:(msg)
	CompileCommandTokens [  3] type 4 comp 0 3:(msg)
	CompileCommandTokens [  4] type 1 comp 4 13:("    $dirs

")
	CompileCommandTokens [  5] type 4 comp 0 4:(    )
	CompileCommandTokens [  6] type 32 comp 1 5:($dirs)
	CompileCommandTokens [  7] type 4 comp 0 4:(dirs)
	CompileCommandTokens [  8] type 4 comp 0 2:(

)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 118: (    append msg "$errors

"
    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(append)
	CompileCommandTokens [  1] type 4 comp 0 6:(append)
	CompileCommandTokens [  2] type 2 comp 1 3:(msg)
	CompileCommandTokens [  3] type 4 comp 0 3:(msg)
	CompileCommandTokens [  4] type 1 comp 3 11:("$errors

")
	CompileCommandTokens [  5] type 32 comp 1 7:($errors)
	CompileCommandTokens [  6] type 4 comp 0 6:(errors)
	CompileCommandTokens [  7] type 4 comp 0 2:(

)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 91: (    append msg "This probably means that Tcl wasn't installed properly.
"
    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(append)
	CompileCommandTokens [  1] type 4 comp 0 6:(append)
	CompileCommandTokens [  2] type 2 comp 1 3:(msg)
	CompileCommandTokens [  3] type 4 comp 0 3:(msg)
	CompileCommandTokens [  4] type 2 comp 1 58:("This probably means that Tcl wasn't installed properly.
")
	CompileCommandTokens [  5] type 4 comp 0 56:(This probably means that Tcl wasn't installed properly.
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 17: (    error $msg
  )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 5:(error)
	CompileCommandTokens [  1] type 4 comp 0 5:(error)
	CompileCommandTokens [  2] type 1 comp 2 4:($msg)
	CompileCommandTokens [  3] type 32 comp 1 4:($msg)
	CompileCommandTokens [  4] type 4 comp 0 3:(msg)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (  )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38302788
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240f10
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'rename'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 38: (::tcl::pkgconfig get scriptdir,runtime)
	TclCompileScript parse 38: (::tcl::pkgconfig get scriptdir,runtime)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 16:(::tcl::pkgconfig)
	CompileCommandTokens [  1] type 4 comp 0 16:(::tcl::pkgconfig)
	CompileCommandTokens [  2] type 2 comp 1 3:(get)
	CompileCommandTokens [  3] type 4 comp 0 3:(get)
	CompileCommandTokens [  4] type 2 comp 1 17:(scriptdir,runtime)
	CompileCommandTokens [  5] type 4 comp 0 17:(scriptdir,runtime)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831e878
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::pkgconfig'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::file::join'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::file::exists'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 30: (::tcl::zipfs::tcl_library_init)
	TclCompileScript parse 30: (::tcl::zipfs::tcl_library_init)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 30:(::tcl::zipfs::tcl_library_init)
	CompileCommandTokens [  1] type 4 comp 0 30:(::tcl::zipfs::tcl_library_init)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38314498
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd '::tcl::zipfs::tcl_library_init'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::file::join'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::file::exists'
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'source'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 23503: (# init.tcl --
#
# Default system startup file for Tcl-based applications.  Defines
# "unknown" procedure and auto-load facilities.
#
# Copyright © 1991-1993 The Regents of the University of California.
# Copyright © 1994-1996 Sun Microsystems, Inc.
# Copyright © 1998-1999 Scriptics Corporation.
# Copyright © 2004 Kevin B. Kenny.
# Copyright © 2018 Sean Woods
#
# All rights reserved.
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
#

# This test intentionally written in pre-7.5 Tcl
if {[info commands package] == ""} {
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 23503: (# init.tcl --
#
# Default system startup file for Tcl-based applications.  Defines
# "unknown" procedure and auto-load facilities.
#
# Copyright © 1991-1993 The Regents of the University of California.
# Copyright © 1994-1996 Sun Microsystems, Inc.
# Copyright © 1998-1999 Scriptics Corporation.
# Copyright © 2004 Kevin B. Kenny.
# Copyright © 2018 Sean Woods
#
# All rights reserved.
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
#

# This test intentionally written in pre-7.5 Tcl
if {[info commands package] == ""} {
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 31:({[info commands package] == ""})
	CompileCommandTokens [  3] type 4 comp 0 29:([info commands package] == "")
	CompileCommandTokens [  4] type 2 comp 1 134:({
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
})
	CompileCommandTokens [  5] type 4 comp 0 132:(
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 82 const 0 mark 0 (-2, -3)
	TclCompileScript 21: (info commands package] == ""} {
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 21: (info commands package] == ""} {
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 8:(commands)
	CompileCommandTokens [  3] type 4 comp 0 8:(commands)
	CompileCommandTokens [  4] type 2 comp 1 7:(package)
	CompileCommandTokens [  5] type 4 comp 0 7:(package)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 82 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 132: (
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 132: (
    error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 5:(error)
	CompileCommandTokens [  1] type 4 comp 0 5:(error)
	CompileCommandTokens [  2] type 1 comp 6 120:("version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]")
	CompileCommandTokens [  3] type 4 comp 0 25:(version mismatch: library)
	CompileCommandTokens [  4] type 8 comp 0 2:(\n)
	CompileCommandTokens [  5] type 4 comp 0 67:(scripts expect Tcl version 7.5b1 or later but the loaded version is)
	CompileCommandTokens [  6] type 8 comp 0 2:(\n)
	CompileCommandTokens [  7] type 4 comp 0 5:(only )
	CompileCommandTokens [  8] type 16 comp 0 17:([info patchlevel])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 15: (info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 15: (info patchlevel]"
}
package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 10:(patchlevel)
	CompileCommandTokens [  3] type 4 comp 0 10:(patchlevel)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 22757: (package require -exact tcl 8.7a6

# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 7:(package)
	CompileCommandTokens [  1] type 4 comp 0 7:(package)
	CompileCommandTokens [  2] type 2 comp 1 7:(require)
	CompileCommandTokens [  3] type 4 comp 0 7:(require)
	CompileCommandTokens [  4] type 2 comp 1 6:(-exact)
	CompileCommandTokens [  5] type 4 comp 0 6:(-exact)
	CompileCommandTokens [  6] type 2 comp 1 3:(tcl)
	CompileCommandTokens [  7] type 4 comp 0 3:(tcl)
	CompileCommandTokens [  8] type 2 comp 1 5:(8.7a6)
	CompileCommandTokens [  9] type 4 comp 0 5:(8.7a6)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 22724: (
# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located.  This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
#	On UNIX it is compiled in
#       On Windows, it is not used
#
# (Ticket 41c9857bdd) In a safe interpreter, this file does not set
# ::auto_path (other than to {} if it is undefined). The caller, typically
# a Safe Base command, is responsible for setting ::auto_path.

if {![info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 26:({![info exists auto_path]})
	CompileCommandTokens [  3] type 4 comp 0 24:(![info exists auto_path])
	CompileCommandTokens [  4] type 2 comp 1 135:({
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
})
	CompileCommandTokens [  5] type 4 comp 0 133:(
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 21: (info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 21: (info exists auto_path]} {
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 9:(auto_path)
	CompileCommandTokens [  5] type 4 comp 0 9:(auto_path)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 133: (
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 133: (
    if {[info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 53:({[info exists env(TCLLIBPATH)] && (![interp issafe])})
	CompileCommandTokens [  3] type 4 comp 0 51:([info exists env(TCLLIBPATH)] && (![interp issafe]))
	CompileCommandTokens [  4] type 2 comp 1 39:({
	set auto_path $env(TCLLIBPATH)
    })
	CompileCommandTokens [  5] type 4 comp 0 37:(
	set auto_path $env(TCLLIBPATH)
    )
	CompileCommandTokens [  6] type 2 comp 1 4:(else)
	CompileCommandTokens [  7] type 4 comp 0 4:(else)
	CompileCommandTokens [  8] type 2 comp 1 25:({
	set auto_path ""
    })
	CompileCommandTokens [  9] type 4 comp 0 23:(
	set auto_path ""
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 84 const 0 mark 0 (-2, 2)
	TclCompileScript 27: (info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 27: (info exists env(TCLLIBPATH)] && (![interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 15:(env(TCLLIBPATH))
	CompileCommandTokens [  5] type 4 comp 0 15:(env(TCLLIBPATH))
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 1 (-2, 2)
CompileExprTree Processing @2 (lex 133 const 0 mark 1 (1633771873, 3)
CompileExprTree Processing @3 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 13: (interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 13: (interp issafe])} {
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 6:(interp)
	CompileCommandTokens [  1] type 4 comp 0 6:(interp)
	CompileCommandTokens [  2] type 2 comp 1 6:(issafe)
	CompileCommandTokens [  3] type 4 comp 0 6:(issafe)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @3 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @2 (lex 133 const 0 mark 2 (1633771873, 3)
CompileExprTree Processing @1 (lex 84 const 0 mark 2 (-2, 2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 37: (
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 37: (
	set auto_path $env(TCLLIBPATH)
    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 9:(auto_path)
	CompileCommandTokens [  3] type 4 comp 0 9:(auto_path)
	CompileCommandTokens [  4] type 1 comp 3 16:($env(TCLLIBPATH))
	CompileCommandTokens [  5] type 32 comp 2 16:($env(TCLLIBPATH))
	CompileCommandTokens [  6] type 4 comp 0 3:(env)
	CompileCommandTokens [  7] type 4 comp 0 10:(TCLLIBPATH)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    } else {
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 23: (
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 23: (
	set auto_path ""
    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 9:(auto_path)
	CompileCommandTokens [  3] type 4 comp 0 9:(auto_path)
	CompileCommandTokens [  4] type 2 comp 1 2:("")
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }
}
namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 21521: (namespace eval tcl {
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
}

namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 3:(tcl)
	CompileCommandTokens [  5] type 4 comp 0 3:(tcl)
	CompileCommandTokens [  6] type 1 comp 3 653:({
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname \
		[info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
})
	CompileCommandTokens [  7] type 4 comp 0 228:(
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname )
	CompileCommandTokens [  8] type 8 comp 0 4:(\
		)
	CompileCommandTokens [  9] type 4 comp 0 419:([info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 20848: (
namespace eval tcl::Pkg {}


# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 8:(tcl::Pkg)
	CompileCommandTokens [  5] type 4 comp 0 8:(tcl::Pkg)
	CompileCommandTokens [  6] type 2 comp 1 2:({})
	CompileCommandTokens [  7] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 20820: (

# Setup the unknown package handler


if {[interp issafe]} {
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
}

# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 17:({[interp issafe]})
	CompileCommandTokens [  3] type 4 comp 0 15:([interp issafe])
	CompileCommandTokens [  4] type 2 comp 1 67:({
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
})
	CompileCommandTokens [  5] type 4 comp 0 65:(
    package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
)
	CompileCommandTokens [  6] type 2 comp 1 4:(else)
	CompileCommandTokens [  7] type 4 comp 0 4:(else)
	CompileCommandTokens [  8] type 1 comp 3 778:({
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler \
		{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
})
	CompileCommandTokens [  9] type 4 comp 0 235:(
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler )
	CompileCommandTokens [ 10] type 8 comp 0 4:(\
		)
	CompileCommandTokens [ 11] type 4 comp 0 537:({::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 19907: (
# Conditionalize for presence of exec.

if {[namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 39:({[namespace which -command exec] eq ""})
	CompileCommandTokens [  3] type 4 comp 0 37:([namespace which -command exec] eq "")
	CompileCommandTokens [  4] type 2 comp 1 131:({

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
})
	CompileCommandTokens [  5] type 4 comp 0 129:(

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 86 const 0 mark 0 (-2, -3)
	TclCompileScript 29: (namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 29: (namespace which -command exec] eq ""} {

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 8:(-command)
	CompileCommandTokens [  5] type 4 comp 0 8:(-command)
	CompileCommandTokens [  6] type 2 comp 1 4:(exec)
	CompileCommandTokens [  7] type 4 comp 0 4:(exec)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 129: (

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 129: (

    # Some machines do not have exec. Also, on all
    # platforms, safe interpreters do not have exec.

    set auto_noexec 1
}

# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 11:(auto_noexec)
	CompileCommandTokens [  3] type 4 comp 0 11:(auto_noexec)
	CompileCommandTokens [  4] type 2 comp 1 1:(1)
	CompileCommandTokens [  5] type 4 comp 0 1:(1)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 19691: (
# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)

if {[namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 41:({[namespace which -command tclLog] eq ""})
	CompileCommandTokens [  3] type 4 comp 0 39:([namespace which -command tclLog] eq "")
	CompileCommandTokens [  4] type 2 comp 1 65:({
    proc tclLog {string} {
	catch {puts stderr $string}
    }
})
	CompileCommandTokens [  5] type 4 comp 0 63:(
    proc tclLog {string} {
	catch {puts stderr $string}
    }
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 86 const 0 mark 0 (-2, -3)
	TclCompileScript 31: (namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 31: (namespace which -command tclLog] eq ""} {
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 8:(-command)
	CompileCommandTokens [  5] type 4 comp 0 8:(-command)
	CompileCommandTokens [  6] type 2 comp 1 6:(tclLog)
	CompileCommandTokens [  7] type 4 comp 0 6:(tclLog)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 63: (
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse 63: (
    proc tclLog {string} {
	catch {puts stderr $string}
    }
}

# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 6:(tclLog)
	CompileCommandTokens [  3] type 4 comp 0 6:(tclLog)
	CompileCommandTokens [  4] type 2 comp 1 8:({string})
	CompileCommandTokens [  5] type 4 comp 0 6:(string)
	CompileCommandTokens [  6] type 2 comp 1 36:({
	catch {puts stderr $string}
    })
	CompileCommandTokens [  7] type 4 comp 0 34:(
	catch {puts stderr $string}
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 19461: (
# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter.  It takes the following steps to make the
# command available:
#
#	1. See if the autoload facility can locate the command in a
#	   Tcl script file.  If so, load it and execute it.
#	2. If the command was invoked interactively at top-level:
#	    (a) see if the command exists as an executable UNIX program.
#		If so, "exec" the command.
#	    (b) see if the command requests csh-like history substitution
#		in one of the common forms !!, !<number>, or ^old^new.  If
#		so, emulate csh's history substitution.
#	    (c) see if the command is a unique abbreviation for another
#		command.  If so, invoke the command.
#
# Arguments:
# args -	A list whose elements are the words of the original
#		command, including the command name.

proc unknown args {
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
}

# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 30
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 7:(unknown)
	CompileCommandTokens [  3] type 4 comp 0 7:(unknown)
	CompileCommandTokens [  4] type 2 comp 1 4:(args)
	CompileCommandTokens [  5] type 4 comp 0 4:(args)
	CompileCommandTokens [  6] type 1 comp 23 5588:({
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion\
		    in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked\
			from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode \
			    -errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch \
			[concat exec $redir $new [lrange $args 1 end]] \
			::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo \
		    "\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
		    ::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
	"invalid command name \"$name\""
})
	CompileCommandTokens [  7] type 4 comp 0 485:(
    variable ::tcl::UnknownPending
    global auto_noexec auto_noload env tcl_interactive errorInfo errorCode

    if {[info exists errorInfo]} {
	set savedErrorInfo $errorInfo
    }
    if {[info exists errorCode]} {
	set savedErrorCode $errorCode
    }

    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists UnknownPending($name)]} {
	    return -code error "self-referential recursion)
	CompileCommandTokens [  8] type 8 comp 0 8:(\
		    )
	CompileCommandTokens [  9] type 4 comp 0 1277:(in \"unknown\" for command \"$name\""
	}
	set UnknownPending($name) pending
	set ret [catch {
		auto_load $name [uplevel 1 {::namespace current}]
	} msg opts]
	unset UnknownPending($name)
	if {$ret != 0} {
	    dict append opts -errorinfo "\n    (autoloading \"$name\")"
	    return -options $opts $msg
	}
	if {![array size UnknownPending]} {
	    unset UnknownPending
	}
	if {$msg} {
	    if {[info exists savedErrorCode]} {
		set ::errorCode $savedErrorCode
	    } else {
		unset -nocomplain ::errorCode
	    }
	    if {[info exists savedErrorInfo]} {
		set errorInfo $savedErrorInfo
	    } else {
		unset -nocomplain errorInfo
	    }
	    set code [catch {uplevel 1 $args} msg opts]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc.
		# construct the stack trace.
		#
		set errInfo [dict get $opts -errorinfo]
		set errCode [dict get $opts -errorcode]
		set cinfo $args
		if {[string length [encoding convertto utf-8 $cinfo]] > 150} {
		    set cinfo [string range $cinfo 0 150]
		    while {[string length [encoding convertto utf-8 $cinfo]] > 150} {
			set cinfo [string range $cinfo 0 end-1]
		    }
		    append cinfo ...
		}
		set tail "\n    (\"uplevel\" body line 1)\n    invoked)
	CompileCommandTokens [ 10] type 8 comp 0 5:(\
			)
	CompileCommandTokens [ 11] type 4 comp 0 886:(from within\n\"uplevel 1 \$args\""
		set expect "$msg\n    while executing\n\"$cinfo\"$tail"
		if {$errInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    dict unset opts -errorinfo
		    dict incr opts -level
		    return -options $opts $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] != [string length $errInfo]} {
		    # Very likely cannot happen
		    return -options $opts $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\"$cinfo\""
		set last [string last $tail $errInfo]
		if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} {
		    return -code error -errorcode $errCode )
	CompileCommandTokens [ 12] type 8 comp 0 9:(\
			    )
	CompileCommandTokens [ 13] type 4 comp 0 270:(-errorinfo $errInfo $msg
		}
		set errInfo [string range $errInfo 0 $last-1]
		set tail "\n    invoked from within\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode )
	CompileCommandTokens [ 14] type 8 comp 0 9:(\
			    )
	CompileCommandTokens [ 15] type 4 comp 0 243:(-errorinfo [string range $errInfo 0 $last-1] $msg
		}
		set tail "\n    while executing\n"
		set last [string last $tail $errInfo]
		if {$last + [string length $tail] == [string length $errInfo]} {
		    return -code error -errorcode $errCode )
	CompileCommandTokens [ 16] type 8 comp 0 9:(\
			    )
	CompileCommandTokens [ 17] type 4 comp 0 503:(-errorinfo [string range $errInfo 0 $last-1] $msg
		}
		return -options $opts $msg
	    } else {
		dict incr opts -level
		return -options $opts $msg
	    }
	}
    }

    if {([info level] == 1) && ([info script] eq "")
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new ne ""} {
		set redir ""
		if {[namespace which -command console] eq ""} {
		    set redir ">&@stdout <@stdin"
		}
		uplevel 1 [list ::catch )
	CompileCommandTokens [ 18] type 8 comp 0 5:(\
			)
	CompileCommandTokens [ 19] type 4 comp 0 47:([concat exec $redir $new [lrange $args 1 end]] )
	CompileCommandTokens [ 20] type 8 comp 0 5:(\
			)
	CompileCommandTokens [ 21] type 4 comp 0 572:(::tcl::UnknownResult ::tcl::UnknownOptions]
		dict incr ::tcl::UnknownOptions -level
		return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	    }
	}
	if {$name eq "!!"} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name -> event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    uplevel 1 [list ::catch $newcmd )
	CompileCommandTokens [ 22] type 8 comp 0 8:(\
		    )
	CompileCommandTokens [ 23] type 4 comp 0 312:(::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {$name eq "::"} {
	    set name ""
	}
	if {$ret != 0} {
	    dict append opts -errorinfo )
	CompileCommandTokens [ 24] type 8 comp 0 8:(\
		    )
	CompileCommandTokens [ 25] type 4 comp 0 551:("\n    (expanding command prefix \"$name\" in unknown)"
	    return -options $opts $msg
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	if {$name eq ""} {
	    # Handle empty $name separately due to strangeness
	    # in [string first] (See RFE 1243354)
	    set cmds $candidates
	} else {
	    set cmds [list]
	    foreach x $candidates {
		if {[string first $name $x] == 0} {
		    lappend cmds $x
		}
	    }
	}
	if {[llength $cmds] == 1} {
	    uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] )
	CompileCommandTokens [ 26] type 8 comp 0 8:(\
		    )
	CompileCommandTokens [ 27] type 4 comp 0 330:(::tcl::UnknownResult ::tcl::UnknownOptions]
	    dict incr ::tcl::UnknownOptions -level
	    return -options $::tcl::UnknownOptions $::tcl::UnknownResult
	}
	if {[llength $cmds]} {
	    return -code error "ambiguous command name \"$name\": [lsort $cmds]"
	}
    }
    return -code error -errorcode [list TCL LOOKUP COMMAND $name] )
	CompileCommandTokens [ 28] type 8 comp 0 3:(\
	)
	CompileCommandTokens [ 29] type 4 comp 0 33:("invalid command name \"$name\""
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 13008: (
# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them.  If so, it sources the appropriate
# library file to create the procedure.  Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd -			Name of the command to find and load.
# namespace (optional)  The namespace where the command is being used - must be
#                       a canonical namespace as returned [namespace current]
#                       for instance. If not given, namespace current is used.

proc auto_load {cmd {namespace {}}} {
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
}

# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 9:(auto_load)
	CompileCommandTokens [  3] type 4 comp 0 9:(auto_load)
	CompileCommandTokens [  4] type 2 comp 1 20:({cmd {namespace {}}})
	CompileCommandTokens [  5] type 4 comp 0 18:(cmd {namespace {}})
	CompileCommandTokens [  6] type 2 comp 1 1118:({
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
})
	CompileCommandTokens [  7] type 4 comp 0 1116:(
    global auto_index auto_path

    if {$namespace eq ""} {
	set namespace [uplevel 1 [list ::namespace current]]
    }
    set nameList [auto_qualify $cmd $namespace]
    # workaround non canonical auto_index entries that might be around
    # from older auto_mkindex versions
    lappend nameList $cmd
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    # There's a couple of ways to look for a command of a given
	    # name.  One is to use
	    #    info commands $name
	    # Unfortunately, if the name has glob-magic chars in it like *
	    # or [], it may not match.  For our purposes here, a better
	    # route is to use
	    #    namespace which -command $name
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    if {![info exists auto_path]} {
	return 0
    }

    if {![auto_load_index]} {
	return 0
    }
    foreach name $nameList {
	if {[info exists auto_index($name)]} {
	    namespace eval :: $auto_index($name)
	    if {[namespace which -command $name] ne ""} {
		return 1
	    }
	}
    }
    return 0
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 11298: (
# ::tcl::Pkg::source --
# This procedure provides an alternative "source" command, which doesn't
# register the file for the "package files" command. Safe interpreters
# don't have to do anything special.
#
# Arguments:
# filename

proc ::tcl::Pkg::source {filename} {
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
}

# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 18:(::tcl::Pkg::source)
	CompileCommandTokens [  3] type 4 comp 0 18:(::tcl::Pkg::source)
	CompileCommandTokens [  4] type 2 comp 1 10:({filename})
	CompileCommandTokens [  5] type 4 comp 0 8:(filename)
	CompileCommandTokens [  6] type 2 comp 1 130:({
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
})
	CompileCommandTokens [  7] type 4 comp 0 128:(
    if {[interp issafe]} {
	uplevel 1 [list ::source $filename]
    } else {
	uplevel 1 [list ::source -nopkg $filename]
    }
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 10899: (
# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list.  This is usually invoked within auto_load to load the index
# of available commands.  Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.

proc auto_load_index {} {
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
}

# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 15:(auto_load_index)
	CompileCommandTokens [  3] type 4 comp 0 15:(auto_load_index)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens [  6] type 1 comp 5 1315:({
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") \
				|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) \
				"::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
})
	CompileCommandTokens [  7] type 4 comp 0 916:(
    variable ::tcl::auto_oldpath
    global auto_index auto_path

    if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
	return 0
    }
    set auto_oldpath $auto_path

    # Check if we are a safe interpreter. In that case, we support only
    # newer format tclIndex files.

    set issafe [interp issafe]
    for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
	set dir [lindex $auto_path $i]
	set f ""
	if {$issafe} {
	    catch {source [file join $dir tclIndex]}
	} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
	    continue
	} else {
	    set error [catch {
		fconfigure $f -encoding utf-8 -eofchar "\032 {}"
		set id [gets $f]
		if {$id eq "# Tcl autoload index file, version 2.0"} {
		    eval [read $f]
		} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
		    while {[gets $f line] >= 0} {
			if {([string index $line 0] eq "#") )
	CompileCommandTokens [  8] type 8 comp 0 6:(\
				)
	CompileCommandTokens [  9] type 4 comp 0 104:(|| ([llength $line] != 2)} {
			    continue
			}
			set name [lindex $line 0]
			set auto_index($name) )
	CompileCommandTokens [ 10] type 8 comp 0 6:(\
				)
	CompileCommandTokens [ 11] type 4 comp 0 281:("::tcl::Pkg::source [file join $dir [lindex $line 1]]"
		    }
		} else {
		    error "[file join $dir tclIndex] isn't a proper Tcl index file"
		}
	    } msg opts]
	    if {$f ne ""} {
		close $f
	    }
	    if {$error} {
		return -options $opts $msg
	    }
	}
    }
    return 1
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 9264: (
# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd		The command name. Can be any name accepted for command
#               invocations (Like "foo::::bar").
# namespace	The namespace where the command is being used - must be
#               a canonical namespace as returned by [namespace current]
#               for instance.

proc auto_qualify {cmd namespace} {

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
}

# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 12:(auto_qualify)
	CompileCommandTokens [  3] type 4 comp 0 12:(auto_qualify)
	CompileCommandTokens [  4] type 2 comp 1 15:({cmd namespace})
	CompileCommandTokens [  5] type 4 comp 0 13:(cmd namespace)
	CompileCommandTokens [  6] type 2 comp 1 1131:({

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
})
	CompileCommandTokens [  7] type 4 comp 0 1129:(

    # count separators and clean them up
    # (making sure that foo:::::bar will be treated as foo::bar)
    set n [regsub -all {::+} $cmd :: cmd]

    # Ignore namespace if the name starts with ::
    # Handle special case of only leading ::

    # Before each return case we give an example of which category it is
    # with the following form :
    # (inputCmd, inputNameSpace) -> output

    if {[string match ::* $cmd]} {
	if {$n > 1} {
	    # (::foo::bar , *) -> ::foo::bar
	    return [list $cmd]
	} else {
	    # (::global , *) -> global
	    return [list [string range $cmd 2 end]]
	}
    }

    # Potentially returning 2 elements to try  :
    # (if the current namespace is not the global one)

    if {$n == 0} {
	if {$namespace eq "::"} {
	    # (nocolons , ::) -> nocolons
	    return [list $cmd]
	} else {
	    # (nocolons , ::sub) -> ::sub::nocolons nocolons
	    return [list ${namespace}::$cmd $cmd]
	}
    } elseif {$namespace eq "::"} {
	#  (foo::bar , ::) -> ::foo::bar
	return [list ::$cmd]
    } else {
	# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
	return [list ${namespace}::$cmd ::$cmd]
    }
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 7413: (
# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library.  If so, the commands are loaded so
# that they will be available for the import links.  If not, then this
# procedure does nothing.
#
# Arguments -
# pattern	The pattern of commands being imported (like "foo::*")
#               a canonical namespace as returned by [namespace current]

proc auto_import {pattern} {
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
}

# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 11:(auto_import)
	CompileCommandTokens [  3] type 4 comp 0 11:(auto_import)
	CompileCommandTokens [  4] type 2 comp 1 9:({pattern})
	CompileCommandTokens [  5] type 4 comp 0 7:(pattern)
	CompileCommandTokens [  6] type 2 comp 1 576:({
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
})
	CompileCommandTokens [  7] type 4 comp 0 574:(
    global auto_index

    # If no namespace is specified, this will be an error case

    if {![string match *::* $pattern]} {
	return
    }

    set ns [uplevel 1 [list ::namespace current]]
    set patternList [auto_qualify $pattern $ns]

    auto_load_index

    foreach pattern $patternList {
        foreach name [array names auto_index $pattern] {
            if {([namespace which -command $name] eq "")
		    && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
                namespace eval :: $auto_index($name)
            }
        }
    }
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 6394: (
# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise.  Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name -			Name of a command.

if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

} else {
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

}

# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 38:({$tcl_platform(platform) eq "windows"})
	CompileCommandTokens [  3] type 4 comp 0 36:($tcl_platform(platform) eq "windows")
	CompileCommandTokens [  4] type 1 comp 3 2278:({
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \
	    md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

})
	CompileCommandTokens [  5] type 4 comp 0 543:(
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions.  Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
    global auto_execs env tcl_platform

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""

    set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype )
	CompileCommandTokens [  6] type 8 comp 0 7:(\
	    )
	CompileCommandTokens [  7] type 4 comp 0 1726:(md mkdir mklink move rd ren rename rmdir start time type ver vol]
    if {[info exists env(PATHEXT)]} {
	# Add an initial ; to have the {} extension check first.
	set execExtensions [split ";$env(PATHEXT)" ";"]
    } else {
	set execExtensions [list {} .com .exe .bat .cmd]
    }

    if {[string tolower $name] in $shellBuiltins} {
	# When this is command.com for some reason on Win2K, Tcl won't
	# exec it unless the case is right, which this corrects.  COMSPEC
	# may not point to a real file, so do the check.
	set cmd $env(COMSPEC)
	if {[file exists $cmd]} {
	    set cmd [file attributes $cmd -shortname]
	}
	return [set auto_execs($name) [list $cmd /c $name]]
    }

    if {[llength [file split $name]] != 1} {
	foreach ext $execExtensions {
	    set file ${name}${ext}
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
	return ""
    }

    set path "[file dirname [info nameof]];.;"
    if {[info exists env(SystemRoot)]} {
	set windir $env(SystemRoot)
    } elseif {[info exists env(WINDIR)]} {
	set windir $env(WINDIR)
    }
    if {[info exists windir]} {
	append path "$windir/system32;$windir/system;$windir;"
    }

    foreach var {PATH Path path} {
	if {[info exists env($var)]} {
	    append path ";$env($var)"
	}
    }

    foreach ext $execExtensions {
	unset -nocomplain checked
	foreach dir [split $path {;}] {
	    # Skip already checked directories
	    if {[info exists checked($dir)] || ($dir eq "")} {
		continue
	    }
	    set checked($dir) {}
	    set file [file join $dir ${name}${ext}]
	    if {[file exists $file] && ![file isdirectory $file]} {
		return [set auto_execs($name) [list $file]]
	    }
	}
    }
    return ""
}

)
	CompileCommandTokens [  8] type 2 comp 1 4:(else)
	CompileCommandTokens [  9] type 4 comp 0 4:(else)
	CompileCommandTokens [ 10] type 2 comp 1 626:({
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

})
	CompileCommandTokens [ 11] type 4 comp 0 624:(
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3109: (
# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail.  The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src.  If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action -              "renaming" or "copying"
# src -			source directory
# dest -		destination directory
proc tcl::CopyDirectory {action src dest} {
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
}
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 28
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 18:(tcl::CopyDirectory)
	CompileCommandTokens [  3] type 4 comp 0 18:(tcl::CopyDirectory)
	CompileCommandTokens [  4] type 2 comp 1 17:({action src dest})
	CompileCommandTokens [  5] type 4 comp 0 15:(action src dest)
	CompileCommandTokens [  6] type 1 comp 21 2553:({
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to\
	      \"$dest\": trying to rename a volume or move a directory\
	      into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to\
	    # \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest \
		    -type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to\
		      \"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to\
		  \"$dest\": trying to rename a volume or move a directory\
		  into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] \
      [glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
})
	CompileCommandTokens [  7] type 4 comp 0 304:(
    set nsrc [file normalize $src]
    set ndest [file normalize $dest]

    if {$action eq "renaming"} {
	# Can't rename volumes.  We could give a more precise
	# error message here, but that would break the test suite.
	if {$nsrc in [file volumes]} {
	    return -code error "error $action \"$src\" to)
	CompileCommandTokens [  8] type 8 comp 0 9:(\
	      )
	CompileCommandTokens [  9] type 4 comp 0 56:(\"$dest\": trying to rename a volume or move a directory)
	CompileCommandTokens [ 10] type 8 comp 0 9:(\
	      )
	CompileCommandTokens [ 11] type 4 comp 0 127:(into itself"
	}
    }
    if {[file exists $dest]} {
	if {$nsrc eq $ndest} {
	    return -code error "error $action \"$src\" to)
	CompileCommandTokens [ 12] type 8 comp 0 9:(\
	      )
	CompileCommandTokens [ 13] type 4 comp 0 56:(\"$dest\": trying to rename a volume or move a directory)
	CompileCommandTokens [ 14] type 8 comp 0 9:(\
	      )
	CompileCommandTokens [ 15] type 4 comp 0 404:(into itself"
	}
	if {$action eq "copying"} {
	    # We used to throw an error here, but, looking more closely
	    # at the core copy code in tclFCmd.c, if the destination
	    # exists, then we should only call this function if -force
	    # is true, which means we just want to over-write.  So,
	    # the following code is now commented out.
	    #
	    # return -code error "error $action \"$src\" to)
	CompileCommandTokens [ 16] type 8 comp 0 7:(\
	    )
	CompileCommandTokens [ 17] type 4 comp 0 388:(# \"$dest\": file already exists"
	} else {
	    # Depending on the platform, and on the current
	    # working directory, the directories '.', '..'
	    # can be returned in various combinations.  Anyway,
	    # if any other file is returned, we must signal an error.
	    set existing [glob -nocomplain -directory $dest * .*]
	    lappend existing {*}[glob -nocomplain -directory $dest )
	CompileCommandTokens [ 18] type 8 comp 0 8:(\
		    )
	CompileCommandTokens [ 19] type 4 comp 0 131:(-type hidden * .*]
	    foreach s $existing {
		if {[file tail $s] ni {. ..}} {
		    return -code error "error $action \"$src\" to)
	CompileCommandTokens [ 20] type 8 comp 0 10:(\
		      )
	CompileCommandTokens [ 21] type 4 comp 0 297:(\"$dest\": file already exists"
		}
	    }
	}
    } else {
	if {[string first $nsrc $ndest] >= 0} {
	    set srclen [expr {[llength [file split $nsrc]] - 1}]
	    set ndest [lindex [file split $ndest] $srclen]
	    if {$ndest eq [file tail $nsrc]} {
		return -code error "error $action \"$src\" to)
	CompileCommandTokens [ 22] type 8 comp 0 6:(\
		  )
	CompileCommandTokens [ 23] type 4 comp 0 56:(\"$dest\": trying to rename a volume or move a directory)
	CompileCommandTokens [ 24] type 8 comp 0 6:(\
		  )
	CompileCommandTokens [ 25] type 4 comp 0 442:(into itself"
	    }
	}
	file mkdir $dest
    }
    # Have to be careful to capture both visible and hidden files.
    # We will also be more generous to the file system and not
    # assume the hidden and non-hidden lists are non-overlapping.
    #
    # On Unix 'hidden' files begin with '.'.  On other platforms
    # or filesystems hidden files may have other interpretations.
    set filelist [concat [glob -nocomplain -directory $src *] )
	CompileCommandTokens [ 26] type 8 comp 0 8:(\
      )
	CompileCommandTokens [ 27] type 4 comp 0 209:([glob -nocomplain -directory $src -types hidden *]]

    foreach s [lsort -unique $filelist] {
	if {[file tail $s] ni {. ..}} {
	    file copy -force -- $s [file join $dest [file tail $s]]
	}
    }
    return
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3839b7b8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241030
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::info::commands'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'package'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 648: (
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 648: (
    if {![interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 18:({![interp issafe]})
	CompileCommandTokens [  3] type 4 comp 0 16:(![interp issafe])
	CompileCommandTokens [  4] type 2 comp 1 620:({
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    })
	CompileCommandTokens [  5] type 4 comp 0 618:(
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 13: (interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 13: (interp issafe]} {
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 6:(interp)
	CompileCommandTokens [  1] type 4 comp 0 6:(interp)
	CompileCommandTokens [  2] type 2 comp 1 6:(issafe)
	CompileCommandTokens [  3] type 4 comp 0 6:(issafe)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 618: (
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 618: (
	variable Dir
	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 8:(variable)
	CompileCommandTokens [  1] type 4 comp 0 8:(variable)
	CompileCommandTokens [  2] type 2 comp 1 3:(Dir)
	CompileCommandTokens [  3] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 603: (	foreach Dir [list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 3:(Dir)
	CompileCommandTokens [  3] type 4 comp 0 3:(Dir)
	CompileCommandTokens [  4] type 1 comp 1 51:([list $::tcl_library [file dirname $::tcl_library]])
	CompileCommandTokens [  5] type 16 comp 0 51:([list $::tcl_library [file dirname $::tcl_library]])
	CompileCommandTokens [  6] type 2 comp 1 71:({
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	})
	CompileCommandTokens [  7] type 4 comp 0 69:(
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 49: (list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 49: (list $::tcl_library [file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 14:($::tcl_library)
	CompileCommandTokens [  3] type 32 comp 1 14:($::tcl_library)
	CompileCommandTokens [  4] type 4 comp 0 13:(::tcl_library)
	CompileCommandTokens [  5] type 1 comp 1 29:([file dirname $::tcl_library])
	CompileCommandTokens [  6] type 16 comp 0 29:([file dirname $::tcl_library])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 27: (file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 27: (file dirname $::tcl_library]] {
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	}
	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 7:(dirname)
	CompileCommandTokens [  3] type 4 comp 0 7:(dirname)
	CompileCommandTokens [  4] type 1 comp 2 14:($::tcl_library)
	CompileCommandTokens [  5] type 32 comp 1 14:($::tcl_library)
	CompileCommandTokens [  6] type 4 comp 0 13:(::tcl_library)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 466: (	set Dir [file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(Dir)
	CompileCommandTokens [  3] type 4 comp 0 3:(Dir)
	CompileCommandTokens [  4] type 1 comp 1 70:([file join [file dirname [file dirname  [info nameofexecutable]]] lib])
	CompileCommandTokens [  5] type 16 comp 0 70:([file join [file dirname [file dirname  [info nameofexecutable]]] lib])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 68: (file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 68: (file join [file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 4:(join)
	CompileCommandTokens [  3] type 4 comp 0 4:(join)
	CompileCommandTokens [  4] type 1 comp 1 54:([file dirname [file dirname  [info nameofexecutable]]])
	CompileCommandTokens [  5] type 16 comp 0 54:([file dirname [file dirname  [info nameofexecutable]]])
	CompileCommandTokens [  6] type 2 comp 1 3:(lib)
	CompileCommandTokens [  7] type 4 comp 0 3:(lib)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 52: (file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 52: (file dirname [file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 7:(dirname)
	CompileCommandTokens [  3] type 4 comp 0 7:(dirname)
	CompileCommandTokens [  4] type 1 comp 1 39:([file dirname  [info nameofexecutable]])
	CompileCommandTokens [  5] type 16 comp 0 39:([file dirname  [info nameofexecutable]])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 37: (file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 37: (file dirname  [info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 7:(dirname)
	CompileCommandTokens [  3] type 4 comp 0 7:(dirname)
	CompileCommandTokens [  4] type 1 comp 1 23:([info nameofexecutable])
	CompileCommandTokens [  5] type 16 comp 0 23:([info nameofexecutable])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 21: (info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 21: (info nameofexecutable]]] lib]
	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 16:(nameofexecutable)
	CompileCommandTokens [  3] type 4 comp 0 16:(nameofexecutable)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 386: (	if {$Dir ni $::auto_path} {
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({$Dir ni $::auto_path})
	CompileCommandTokens [  3] type 4 comp 0 20:($Dir ni $::auto_path)
	CompileCommandTokens [  4] type 2 comp 1 34:({
	    lappend ::auto_path $Dir
	})
	CompileCommandTokens [  5] type 4 comp 0 32:(
	    lappend ::auto_path $Dir
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 90 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 32: (
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 32: (
	    lappend ::auto_path $Dir
	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 11:(::auto_path)
	CompileCommandTokens [  3] type 4 comp 0 11:(::auto_path)
	CompileCommandTokens [  4] type 1 comp 2 4:($Dir)
	CompileCommandTokens [  5] type 32 comp 1 4:($Dir)
	CompileCommandTokens [  6] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}
	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 324: (	if {[info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 29:({[info exists ::tcl_pkgPath]})
	CompileCommandTokens [  3] type 4 comp 0 27:([info exists ::tcl_pkgPath])
	CompileCommandTokens [  4] type 2 comp 1 119:({ catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}})
	CompileCommandTokens [  5] type 4 comp 0 117:( catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	})
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 25: (info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 25: (info exists ::tcl_pkgPath]} { catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(exists)
	CompileCommandTokens [  3] type 4 comp 0 6:(exists)
	CompileCommandTokens [  4] type 2 comp 1 13:(::tcl_pkgPath)
	CompileCommandTokens [  5] type 4 comp 0 13:(::tcl_pkgPath)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
	TclCompileScript 117: ( catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 117: ( catch {
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 5:(catch)
	CompileCommandTokens [  1] type 4 comp 0 5:(catch)
	CompileCommandTokens [  2] type 2 comp 1 110:({
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	})
	CompileCommandTokens [  3] type 4 comp 0 108:(
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 108: (
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 108: (
	    foreach Dir $::tcl_pkgPath {
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    }
	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 3:(Dir)
	CompileCommandTokens [  3] type 4 comp 0 3:(Dir)
	CompileCommandTokens [  4] type 1 comp 2 14:($::tcl_pkgPath)
	CompileCommandTokens [  5] type 32 comp 1 14:($::tcl_pkgPath)
	CompileCommandTokens [  6] type 4 comp 0 13:(::tcl_pkgPath)
	CompileCommandTokens [  7] type 2 comp 1 73:({
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    })
	CompileCommandTokens [  8] type 4 comp 0 71:(
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}}

	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 170: (
	variable Path [encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 8:(variable)
	CompileCommandTokens [  1] type 4 comp 0 8:(variable)
	CompileCommandTokens [  2] type 2 comp 1 4:(Path)
	CompileCommandTokens [  3] type 4 comp 0 4:(Path)
	CompileCommandTokens [  4] type 1 comp 1 15:([encoding dirs])
	CompileCommandTokens [  5] type 16 comp 0 15:([encoding dirs])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 13: (encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 13: (encoding dirs]
	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 8:(encoding)
	CompileCommandTokens [  1] type 4 comp 0 8:(encoding)
	CompileCommandTokens [  2] type 2 comp 1 4:(dirs)
	CompileCommandTokens [  3] type 4 comp 0 4:(dirs)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 138: (	set Dir [file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(Dir)
	CompileCommandTokens [  3] type 4 comp 0 3:(Dir)
	CompileCommandTokens [  4] type 1 comp 1 35:([file join $::tcl_library encoding])
	CompileCommandTokens [  5] type 16 comp 0 35:([file join $::tcl_library encoding])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 33: (file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 33: (file join $::tcl_library encoding]
	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(file)
	CompileCommandTokens [  1] type 4 comp 0 4:(file)
	CompileCommandTokens [  2] type 2 comp 1 4:(join)
	CompileCommandTokens [  3] type 4 comp 0 4:(join)
	CompileCommandTokens [  4] type 1 comp 2 14:($::tcl_library)
	CompileCommandTokens [  5] type 32 comp 1 14:($::tcl_library)
	CompileCommandTokens [  6] type 4 comp 0 13:(::tcl_library)
	CompileCommandTokens [  7] type 2 comp 1 8:(encoding)
	CompileCommandTokens [  8] type 4 comp 0 8:(encoding)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 93: (	if {$Dir ni $Path} {
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 15:({$Dir ni $Path})
	CompileCommandTokens [  3] type 4 comp 0 13:($Dir ni $Path)
	CompileCommandTokens [  4] type 2 comp 1 52:({
	    lappend Path $Dir
	    encoding dirs $Path
	})
	CompileCommandTokens [  5] type 4 comp 0 50:(
	    lappend Path $Dir
	    encoding dirs $Path
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 90 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 50: (
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse 50: (
	    lappend Path $Dir
	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 4:(Path)
	CompileCommandTokens [  3] type 4 comp 0 4:(Path)
	CompileCommandTokens [  4] type 1 comp 2 4:($Dir)
	CompileCommandTokens [  5] type 32 comp 1 4:($Dir)
	CompileCommandTokens [  6] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 26: (	    encoding dirs $Path
	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 8:(encoding)
	CompileCommandTokens [  1] type 4 comp 0 8:(encoding)
	CompileCommandTokens [  2] type 2 comp 1 4:(dirs)
	CompileCommandTokens [  3] type 4 comp 0 4:(dirs)
	CompileCommandTokens [  4] type 1 comp 2 5:($Path)
	CompileCommandTokens [  5] type 32 comp 1 5:($Path)
	CompileCommandTokens [  6] type 4 comp 0 4:(Path)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}
	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 20: (	unset Dir Path
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 5:(unset)
	CompileCommandTokens [  1] type 4 comp 0 5:(unset)
	CompileCommandTokens [  2] type 2 comp 1 3:(Dir)
	CompileCommandTokens [  3] type 4 comp 0 3:(Dir)
	CompileCommandTokens [  4] type 2 comp 1 4:(Path)
	CompileCommandTokens [  5] type 4 comp 0 4:(Path)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a1658
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241140
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'interp'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'variable'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::file::dirname'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'foreach'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 69: (
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse 69: (
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({$Dir ni $::auto_path})
	CompileCommandTokens [  3] type 4 comp 0 20:($Dir ni $::auto_path)
	CompileCommandTokens [  4] type 2 comp 1 35:({
		lappend ::auto_path $Dir
	    })
	CompileCommandTokens [  5] type 4 comp 0 33:(
		lappend ::auto_path $Dir
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 90 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 33: (
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse 33: (
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 11:(::auto_path)
	CompileCommandTokens [  3] type 4 comp 0 11:(::auto_path)
	CompileCommandTokens [  4] type 1 comp 2 4:($Dir)
	CompileCommandTokens [  5] type 32 comp 1 4:($Dir)
	CompileCommandTokens [  6] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5: (	    }
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 69: (
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse 69: (
	    if {$Dir ni $::auto_path} {
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({$Dir ni $::auto_path})
	CompileCommandTokens [  3] type 4 comp 0 20:($Dir ni $::auto_path)
	CompileCommandTokens [  4] type 2 comp 1 35:({
		lappend ::auto_path $Dir
	    })
	CompileCommandTokens [  5] type 4 comp 0 33:(
		lappend ::auto_path $Dir
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 90 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 33: (
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse 33: (
		lappend ::auto_path $Dir
	    }
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 11:(::auto_path)
	CompileCommandTokens [  3] type 4 comp 0 11:(::auto_path)
	CompileCommandTokens [  4] type 1 comp 2 4:($Dir)
	CompileCommandTokens [  5] type 32 comp 1 4:($Dir)
	CompileCommandTokens [  6] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5: (	    }
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38389838
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241270
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38389838
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241270
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd '::tcl::info::nameofexecutable'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::file::dirname'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::file::dirname'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::file::join'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'foreach'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 71: (
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse 71: (
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({$Dir ni $::auto_path})
	CompileCommandTokens [  3] type 4 comp 0 20:($Dir ni $::auto_path)
	CompileCommandTokens [  4] type 2 comp 1 36:({
		    lappend ::auto_path $Dir
		})
	CompileCommandTokens [  5] type 4 comp 0 34:(
		    lappend ::auto_path $Dir
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 90 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 34: (
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse 34: (
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 11:(::auto_path)
	CompileCommandTokens [  3] type 4 comp 0 11:(::auto_path)
	CompileCommandTokens [  4] type 1 comp 2 4:($Dir)
	CompileCommandTokens [  5] type 32 comp 1 4:($Dir)
	CompileCommandTokens [  6] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
	    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5: (	    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 71: (
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse 71: (
		if {$Dir ni $::auto_path} {
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({$Dir ni $::auto_path})
	CompileCommandTokens [  3] type 4 comp 0 20:($Dir ni $::auto_path)
	CompileCommandTokens [  4] type 2 comp 1 36:({
		    lappend ::auto_path $Dir
		})
	CompileCommandTokens [  5] type 4 comp 0 34:(
		    lappend ::auto_path $Dir
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 90 const 0 mark 0 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 1 (-2, -2)
CompileExprTree Processing @1 (lex 90 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 34: (
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse 34: (
		    lappend ::auto_path $Dir
		}
	    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 11:(::auto_path)
	CompileCommandTokens [  3] type 4 comp 0 11:(::auto_path)
	CompileCommandTokens [  4] type 1 comp 2 4:($Dir)
	CompileCommandTokens [  5] type 32 comp 1 4:($Dir)
	CompileCommandTokens [  6] type 4 comp 0 3:(Dir)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
	    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 5: (	    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a2b88
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241270
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd '::tcl::encoding::dirs'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'variable'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::file::join'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::encoding::dirs'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 0: ()
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 0: ()
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38309238
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241140
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'if'
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 13: (interp issafe])
	TclCompileScript parse 13: (interp issafe])
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 6:(interp)
	CompileCommandTokens [  1] type 4 comp 0 6:(interp)
	CompileCommandTokens [  2] type 2 comp 1 6:(issafe)
	CompileCommandTokens [  3] type 4 comp 0 6:(issafe)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831d598
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382410d0
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'interp'
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 773: (
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse 773: (
    # Set up search for Tcl Modules (TIP #189).
    # and setup platform specific unknown package handlers
    if {$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"} {
	package unknown {::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 73:({$tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix"})
	CompileCommandTokens [  3] type 4 comp 0 71:($tcl_platform(os) eq "Darwin"
	    && $tcl_platform(platform) eq "unix")
	CompileCommandTokens [  4] type 2 comp 1 95:({
	package unknown {::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    })
	CompileCommandTokens [  5] type 4 comp 0 93:(
	package unknown {::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    )
	CompileCommandTokens [  6] type 2 comp 1 4:(else)
	CompileCommandTokens [  7] type 4 comp 0 4:(else)
	CompileCommandTokens [  8] type 2 comp 1 68:({
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    })
	CompileCommandTokens [  9] type 4 comp 0 66:(
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 2)
CompileExprTree Processing @2 (lex 84 const 0 mark 0 (1, 3)
CompileExprTree Processing @1 (lex 86 const 0 mark 0 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @2 (lex 84 const 0 mark 1 (1, 3)
CompileExprTree Processing @3 (lex 86 const 0 mark 0 (-2, -3)
CompileExprTree Processing @3 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @3 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @2 (lex 84 const 0 mark 2 (1, 3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 2)
		TclCompileExpr /done
	TclCompileScript 93: (
	package unknown {::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse 93: (
	package unknown {::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(package)
	CompileCommandTokens [  1] type 4 comp 0 7:(package)
	CompileCommandTokens [  2] type 2 comp 1 7:(unknown)
	CompileCommandTokens [  3] type 4 comp 0 7:(unknown)
	CompileCommandTokens [  4] type 2 comp 1 70:({::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}})
	CompileCommandTokens [  5] type 4 comp 0 68:(::tcl::tm::UnknownHandler  {::tcl::MacOSXPkgUnknown ::tclPkgUnknown})
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    } else {
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 66: (
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse 66: (
	package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(package)
	CompileCommandTokens [  1] type 4 comp 0 7:(package)
	CompileCommandTokens [  2] type 2 comp 1 7:(unknown)
	CompileCommandTokens [  3] type 4 comp 0 7:(unknown)
	CompileCommandTokens [  4] type 2 comp 1 43:({::tcl::tm::UnknownHandler ::tclPkgUnknown})
	CompileCommandTokens [  5] type 4 comp 0 41:(::tcl::tm::UnknownHandler ::tclPkgUnknown)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }

    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 414: (
    # Set up the 'clock' ensemble

    namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 4:(eval)
	CompileCommandTokens [  3] type 4 comp 0 4:(eval)
	CompileCommandTokens [  4] type 2 comp 1 12:(::tcl::clock)
	CompileCommandTokens [  5] type 4 comp 0 12:(::tcl::clock)
	CompileCommandTokens [  6] type 1 comp 1 40:([list variable TclLibDir $::tcl_library])
	CompileCommandTokens [  7] type 16 comp 0 40:([list variable TclLibDir $::tcl_library])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 38: (list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse 38: (list variable TclLibDir $::tcl_library]

    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 2 comp 1 8:(variable)
	CompileCommandTokens [  3] type 4 comp 0 8:(variable)
	CompileCommandTokens [  4] type 2 comp 1 9:(TclLibDir)
	CompileCommandTokens [  5] type 4 comp 0 9:(TclLibDir)
	CompileCommandTokens [  6] type 1 comp 2 14:($::tcl_library)
	CompileCommandTokens [  7] type 32 comp 1 14:($::tcl_library)
	CompileCommandTokens [  8] type 4 comp 0 13:(::tcl_library)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 305: (
    proc ::tcl::initClock {} {
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    }
    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 16:(::tcl::initClock)
	CompileCommandTokens [  3] type 4 comp 0 16:(::tcl::initClock)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens [  6] type 2 comp 1 253:({
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    })
	CompileCommandTokens [  7] type 4 comp 0 251:(
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 21: (    ::tcl::initClock
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 16:(::tcl::initClock)
	CompileCommandTokens [  1] type 4 comp 0 16:(::tcl::initClock)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3830c358
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382410d0
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'package'
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'variable'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd '::tcl::initClock'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 251: (
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse 251: (
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 3:(cmd)
	CompileCommandTokens [  3] type 4 comp 0 3:(cmd)
	CompileCommandTokens [  4] type 2 comp 1 17:({add format scan})
	CompileCommandTokens [  5] type 4 comp 0 15:(add format scan)
	CompileCommandTokens [  6] type 2 comp 1 146:({
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	})
	CompileCommandTokens [  7] type 4 comp 0 144:(
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 144: (
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse 144: (
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 1 comp 3 18:(::tcl::clock::$cmd)
	CompileCommandTokens [  3] type 4 comp 0 14:(::tcl::clock::)
	CompileCommandTokens [  4] type 32 comp 1 4:($cmd)
	CompileCommandTokens [  5] type 4 comp 0 3:(cmd)
	CompileCommandTokens [  6] type 2 comp 1 4:(args)
	CompileCommandTokens [  7] type 4 comp 0 4:(args)
	CompileCommandTokens [  8] type 2 comp 1 107:({
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    })
	CompileCommandTokens [  9] type 4 comp 0 105:(
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 33: (
	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(rename)
	CompileCommandTokens [  1] type 4 comp 0 6:(rename)
	CompileCommandTokens [  2] type 2 comp 1 16:(::tcl::initClock)
	CompileCommandTokens [  3] type 4 comp 0 16:(::tcl::initClock)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 251: (
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse 251: (
	# Auto-loading stubs for 'clock.tcl'

	foreach cmd {add format scan} {
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 3:(cmd)
	CompileCommandTokens [  3] type 4 comp 0 3:(cmd)
	CompileCommandTokens [  4] type 2 comp 1 17:({add format scan})
	CompileCommandTokens [  5] type 4 comp 0 15:(add format scan)
	CompileCommandTokens [  6] type 2 comp 1 146:({
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	})
	CompileCommandTokens [  7] type 4 comp 0 144:(
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 144: (
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse 144: (
	    proc ::tcl::clock::$cmd args {
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    }
	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 1 comp 3 18:(::tcl::clock::$cmd)
	CompileCommandTokens [  3] type 4 comp 0 14:(::tcl::clock::)
	CompileCommandTokens [  4] type 32 comp 1 4:($cmd)
	CompileCommandTokens [  5] type 4 comp 0 3:(cmd)
	CompileCommandTokens [  6] type 2 comp 1 4:(args)
	CompileCommandTokens [  7] type 4 comp 0 4:(args)
	CompileCommandTokens [  8] type 2 comp 1 107:({
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    })
	CompileCommandTokens [  9] type 4 comp 0 105:(
		variable TclLibDir
		source [file join $TclLibDir clock.tcl]
		return [uplevel 1 [info level 0]]
	    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	}

	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 33: (
	rename ::tcl::initClock {}
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(rename)
	CompileCommandTokens [  1] type 4 comp 0 6:(rename)
	CompileCommandTokens [  2] type 2 comp 1 16:(::tcl::initClock)
	CompileCommandTokens [  3] type 4 comp 0 16:(::tcl::initClock)
	CompileCommandTokens [  4] type 2 comp 1 2:({})
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a6a18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382411e0
TEBCresume ip 0x558f3823dce8 td 0x558f382411e0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f382411e0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f382411e0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f382411e0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'rename'
TEBCresume ip 0x558f3823dce8 td 0x558f382411e0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'if'
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 86 const 0 mark 0 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383ad8f8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382410d0
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 624: (
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

)
	TclCompileScript parse 624: (
# Unix version.
#
proc auto_execok name {
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
}

)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(proc)
	CompileCommandTokens [  1] type 4 comp 0 4:(proc)
	CompileCommandTokens [  2] type 2 comp 1 11:(auto_execok)
	CompileCommandTokens [  3] type 4 comp 0 11:(auto_execok)
	CompileCommandTokens [  4] type 2 comp 1 4:(name)
	CompileCommandTokens [  5] type 4 comp 0 4:(name)
	CompileCommandTokens [  6] type 2 comp 1 581:({
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
})
	CompileCommandTokens [  7] type 4 comp 0 579:(
    global auto_execs env

    if {[info exists auto_execs($name)]} {
	return $auto_execs($name)
    }
    set auto_execs($name) ""
    if {[llength [file split $name]] != 1} {
	if {[file executable $name] && ![file isdirectory $name]} {
	    set auto_execs($name) [list $name]
	}
	return $auto_execs($name)
    }
    foreach dir [split $env(PATH) :] {
	if {$dir eq ""} {
	    set dir .
	}
	set file [file join $dir $name]
	if {[file executable $file] && ![file isdirectory $file]} {
	    set auto_execs($name) [list $file]
	    return $auto_execs($name)
	}
    }
    return ""
)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a5f18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382410d0
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f382410d0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TEBCresume ip 0x558f3823dce8 td 0x558f38241030 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240f10 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'info'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd '::tcl::info::patchlevel'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'puts'
8.7a6
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'proc'
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'oo::class'
TclNRNewObjectInstance
TclInitRewriteEnsemble In  -3 +3 root 1
TclInitRewriteEnsemble Out -3 +3 root 1
TclNRNewObjectInstance push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::define'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 747: (
    method create {name args} {
        if {![string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    }
)
	TclCompileScript parse 747: (
    method create {name args} {
        if {![string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(method)
	CompileCommandTokens [  1] type 4 comp 0 6:(method)
	CompileCommandTokens [  2] type 2 comp 1 6:(create)
	CompileCommandTokens [  3] type 4 comp 0 6:(create)
	CompileCommandTokens [  4] type 2 comp 1 11:({name args})
	CompileCommandTokens [  5] type 4 comp 0 9:(name args)
	CompileCommandTokens [  6] type 2 comp 1 715:({
        if {![string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    })
	CompileCommandTokens [  7] type 4 comp 0 713:(
        if {![string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a5f18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e70
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'method'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::MixinClassDelegates'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 400: (
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 400: (
		if {![info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 33:({![info object isa class $class]})
	CompileCommandTokens [  3] type 4 comp 0 31:(![info object isa class $class])
	CompileCommandTokens [  4] type 2 comp 1 15:({
			return
		})
	CompileCommandTokens [  5] type 4 comp 0 13:(
			return
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 28: (info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 28: (info object isa class $class]} {
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 6:($class)
	CompileCommandTokens [  9] type 32 comp 1 6:($class)
	CompileCommandTokens [ 10] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 13: (
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 13: (
			return
		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 344: (		set delegate [DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 8:(delegate)
	CompileCommandTokens [  3] type 4 comp 0 8:(delegate)
	CompileCommandTokens [  4] type 1 comp 1 21:([DelegateName $class])
	CompileCommandTokens [  5] type 16 comp 0 21:([DelegateName $class])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 19: (DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 19: (DelegateName $class]
		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 12:(DelegateName)
	CompileCommandTokens [  1] type 4 comp 0 12:(DelegateName)
	CompileCommandTokens [  2] type 1 comp 2 6:($class)
	CompileCommandTokens [  3] type 32 comp 1 6:($class)
	CompileCommandTokens [  4] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 307: (		if {![info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 36:({![info object isa class $delegate]})
	CompileCommandTokens [  3] type 4 comp 0 34:(![info object isa class $delegate])
	CompileCommandTokens [  4] type 2 comp 1 15:({
			return
		})
	CompileCommandTokens [  5] type 4 comp 0 13:(
			return
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 31: (info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 31: (info object isa class $delegate]} {
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 9:($delegate)
	CompileCommandTokens [  9] type 32 comp 1 9:($delegate)
	CompileCommandTokens [ 10] type 4 comp 0 8:(delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 13: (
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 13: (
			return
		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 249: (		foreach c [info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 1:(c)
	CompileCommandTokens [  3] type 4 comp 0 1:(c)
	CompileCommandTokens [  4] type 1 comp 1 30:([info class superclass $class])
	CompileCommandTokens [  5] type 16 comp 0 30:([info class superclass $class])
	CompileCommandTokens [  6] type 2 comp 1 144:({
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		})
	CompileCommandTokens [  7] type 4 comp 0 142:(
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 28: (info class superclass $class] {
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 5:(class)
	CompileCommandTokens [  3] type 4 comp 0 5:(class)
	CompileCommandTokens [  4] type 2 comp 1 10:(superclass)
	CompileCommandTokens [  5] type 4 comp 0 10:(superclass)
	CompileCommandTokens [  6] type 1 comp 2 6:($class)
	CompileCommandTokens [  7] type 32 comp 1 6:($class)
	CompileCommandTokens [  8] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 142: (
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 142: (
			set d [DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 1:(d)
	CompileCommandTokens [  3] type 4 comp 0 1:(d)
	CompileCommandTokens [  4] type 1 comp 1 17:([DelegateName $c])
	CompileCommandTokens [  5] type 16 comp 0 17:([DelegateName $c])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 15: (DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 15: (DelegateName $c]
			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 12:(DelegateName)
	CompileCommandTokens [  1] type 4 comp 0 12:(DelegateName)
	CompileCommandTokens [  2] type 1 comp 2 2:($c)
	CompileCommandTokens [  3] type 32 comp 1 2:($c)
	CompileCommandTokens [  4] type 4 comp 0 1:(c)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 114: (			if {![info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 29:({![info object isa class $d]})
	CompileCommandTokens [  3] type 4 comp 0 27:(![info object isa class $d])
	CompileCommandTokens [  4] type 2 comp 1 19:({
				continue
			})
	CompileCommandTokens [  5] type 4 comp 0 17:(
				continue
			)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 24: (info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 24: (info object isa class $d]} {
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 2:($d)
	CompileCommandTokens [  9] type 32 comp 1 2:($d)
	CompileCommandTokens [ 10] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 17: (
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse 17: (
				continue
			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 1 tokens 2
	CompileCommandTokens [  0] type 2 comp 1 8:(continue)
	CompileCommandTokens [  1] type 4 comp 0 8:(continue)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3: (			}
			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 58: (			define $delegate ::oo::define::superclass -append $d
		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 6:(define)
	CompileCommandTokens [  1] type 4 comp 0 6:(define)
	CompileCommandTokens [  2] type 1 comp 2 9:($delegate)
	CompileCommandTokens [  3] type 32 comp 1 9:($delegate)
	CompileCommandTokens [  4] type 4 comp 0 8:(delegate)
	CompileCommandTokens [  5] type 2 comp 1 24:(::oo::define::superclass)
	CompileCommandTokens [  6] type 4 comp 0 24:(::oo::define::superclass)
	CompileCommandTokens [  7] type 2 comp 1 7:(-append)
	CompileCommandTokens [  8] type 4 comp 0 7:(-append)
	CompileCommandTokens [  9] type 1 comp 2 2:($d)
	CompileCommandTokens [ 10] type 32 comp 1 2:($d)
	CompileCommandTokens [ 11] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		}
		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 61: (		objdefine $class ::oo::objdefine::mixin -append $delegate
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 9:(objdefine)
	CompileCommandTokens [  1] type 4 comp 0 9:(objdefine)
	CompileCommandTokens [  2] type 1 comp 2 6:($class)
	CompileCommandTokens [  3] type 32 comp 1 6:($class)
	CompileCommandTokens [  4] type 4 comp 0 5:(class)
	CompileCommandTokens [  5] type 2 comp 1 22:(::oo::objdefine::mixin)
	CompileCommandTokens [  6] type 4 comp 0 22:(::oo::objdefine::mixin)
	CompileCommandTokens [  7] type 2 comp 1 7:(-append)
	CompileCommandTokens [  8] type 4 comp 0 7:(-append)
	CompileCommandTokens [  9] type 1 comp 2 9:($delegate)
	CompileCommandTokens [ 10] type 32 comp 1 9:($delegate)
	CompileCommandTokens [ 11] type 4 comp 0 8:(delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38334a08
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240ec0
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 3:(cat)
	CompileCommandTokens [  3] type 4 comp 0 3:(cat)
	CompileCommandTokens [  4] type 1 comp 1 30:([info object namespace $class])
	CompileCommandTokens [  5] type 16 comp 0 30:([info object namespace $class])
	CompileCommandTokens [  6] type 2 comp 1 18:({:: oo ::delegate})
	CompileCommandTokens [  7] type 4 comp 0 16:(:: oo ::delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  5] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  6] type 1 comp 2 6:($class)
	CompileCommandTokens [  7] type 32 comp 1 6:($class)
	CompileCommandTokens [  8] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 65: (
		string cat [info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 3:(cat)
	CompileCommandTokens [  3] type 4 comp 0 3:(cat)
	CompileCommandTokens [  4] type 1 comp 1 30:([info object namespace $class])
	CompileCommandTokens [  5] type 16 comp 0 30:([info object namespace $class])
	CompileCommandTokens [  6] type 2 comp 1 18:({:: oo ::delegate})
	CompileCommandTokens [  7] type 4 comp 0 16:(:: oo ::delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse 28: (info object namespace $class] {:: oo ::delegate}
	)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  5] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  6] type 1 comp 2 6:($class)
	CompileCommandTokens [  7] type 32 comp 1 6:($class)
	CompileCommandTokens [  8] type 4 comp 0 5:(class)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 1: (	)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240ff0
TEBCresume ip 0x558f3823dce8 td 0x558f38240ff0 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::InfoClass::superclasses'
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241000
TEBCresume ip 0x558f3823dce8 td 0x558f38241000 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::objdefine::mixin'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 184: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 184: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 1 20:([namespace which my])
	CompileCommandTokens [  5] type 16 comp 0 20:([namespace which my])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 2:(my)
	CompileCommandTokens [  5] type 4 comp 0 2:(my)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 152: (			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(args)
	CompileCommandTokens [  3] type 4 comp 0 4:(args)
	CompileCommandTokens [  4] type 1 comp 1 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens [  5] type 16 comp 0 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(lmap)
	CompileCommandTokens [  1] type 4 comp 0 4:(lmap)
	CompileCommandTokens [  2] type 2 comp 1 1:(a)
	CompileCommandTokens [  3] type 4 comp 0 1:(a)
	CompileCommandTokens [  4] type 1 comp 2 5:($args)
	CompileCommandTokens [  5] type 32 comp 1 5:($args)
	CompileCommandTokens [  6] type 4 comp 0 4:(args)
	CompileCommandTokens [  7] type 2 comp 1 33:({uplevel 1 [list $my Resolve $a]})
	CompileCommandTokens [  8] type 4 comp 0 31:(uplevel 1 [list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 31: (uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 31: (uplevel 1 [list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 21:([list $my Resolve $a])
	CompileCommandTokens [  5] type 16 comp 0 21:([list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 19: (list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 19: (list $my Resolve $a]}]
			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 3:($my)
	CompileCommandTokens [  3] type 32 comp 1 3:($my)
	CompileCommandTokens [  4] type 4 comp 0 2:(my)
	CompileCommandTokens [  5] type 2 comp 1 7:(Resolve)
	CompileCommandTokens [  6] type 4 comp 0 7:(Resolve)
	CompileCommandTokens [  7] type 1 comp 2 2:($a)
	CompileCommandTokens [  8] type 32 comp 1 2:($a)
	CompileCommandTokens [  9] type 4 comp 0 1:(a)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 91: (			set current [uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 7:(current)
	CompileCommandTokens [  3] type 4 comp 0 7:(current)
	CompileCommandTokens [  4] type 1 comp 1 26:([uplevel 1 [list $my Get]])
	CompileCommandTokens [  5] type 16 comp 0 26:([uplevel 1 [list $my Get]])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 24: (uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 24: (uplevel 1 [list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 14:([list $my Get])
	CompileCommandTokens [  5] type 16 comp 0 14:([list $my Get])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 12: (list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse 12: (list $my Get]]
			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 3:($my)
	CompileCommandTokens [  3] type 32 comp 1 3:($my)
	CompileCommandTokens [  4] type 4 comp 0 2:(my)
	CompileCommandTokens [  5] type 2 comp 1 3:(Get)
	CompileCommandTokens [  6] type 4 comp 0 3:(Get)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 49: (			tailcall my Set [list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 2 comp 1 3:(Set)
	CompileCommandTokens [  5] type 4 comp 0 3:(Set)
	CompileCommandTokens [  6] type 1 comp 1 27:([list {*}$current {*}$args])
	CompileCommandTokens [  7] type 16 comp 0 27:([list {*}$current {*}$args])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 25: (list {*}$current {*}$args]
		)
	TclCompileScript parse 25: (list {*}$current {*}$args]
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 256 comp 2 11:({*}$current)
	CompileCommandTokens [  3] type 32 comp 1 8:($current)
	CompileCommandTokens [  4] type 4 comp 0 7:(current)
	CompileCommandTokens [  5] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  6] type 32 comp 1 5:($args)
	CompileCommandTokens [  7] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38330cb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382411a0
TEBCresume ip 0x558f3823dce8 td 0x558f382411a0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382411a0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382411a0 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240ec0 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'oo::define'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::define::self'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -2 +1 root 0
TclInitRewriteEnsemble Out -4 +1 root 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::objdefine::mixin'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 190: (
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 190: (
			set def --default-operation
			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(def)
	CompileCommandTokens [  3] type 4 comp 0 3:(def)
	CompileCommandTokens [  4] type 2 comp 1 19:(--default-operation)
	CompileCommandTokens [  5] type 4 comp 0 19:(--default-operation)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 158: (			if {[llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 22:({[llength $args] == 0})
	CompileCommandTokens [  3] type 4 comp 0 20:([llength $args] == 0)
	CompileCommandTokens [  4] type 2 comp 1 27:({
				tailcall my $def
			})
	CompileCommandTokens [  5] type 4 comp 0 25:(
				tailcall my $def
			)
	CompileCommandTokens [  6] type 2 comp 1 6:(elseif)
	CompileCommandTokens [  7] type 4 comp 0 6:(elseif)
	CompileCommandTokens [  8] type 2 comp 1 37:({![string match -* [lindex $args 0]]})
	CompileCommandTokens [  9] type 4 comp 0 35:(![string match -* [lindex $args 0]])
	CompileCommandTokens [ 10] type 2 comp 1 36:({
				tailcall my $def {*}$args
			})
	CompileCommandTokens [ 11] type 4 comp 0 34:(
				tailcall my $def {*}$args
			)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 82 const 0 mark 0 (-2, -3)
	TclCompileScript 13: (llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 13: (llength $args] == 0} {
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 7:(llength)
	CompileCommandTokens [  1] type 4 comp 0 7:(llength)
	CompileCommandTokens [  2] type 1 comp 2 5:($args)
	CompileCommandTokens [  3] type 32 comp 1 5:($args)
	CompileCommandTokens [  4] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 82 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 25: (
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 25: (
				tailcall my $def
			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 2 4:($def)
	CompileCommandTokens [  5] type 32 comp 1 4:($def)
	CompileCommandTokens [  6] type 4 comp 0 3:(def)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3: (			} elseif {![string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 32: (string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 32: (string match -* [lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 5:(match)
	CompileCommandTokens [  3] type 4 comp 0 5:(match)
	CompileCommandTokens [  4] type 2 comp 1 2:(-*)
	CompileCommandTokens [  5] type 4 comp 0 2:(-*)
	CompileCommandTokens [  6] type 1 comp 1 16:([lindex $args 0])
	CompileCommandTokens [  7] type 16 comp 0 16:([lindex $args 0])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 14: (lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 14: (lindex $args 0]]} {
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 6:(lindex)
	CompileCommandTokens [  1] type 4 comp 0 6:(lindex)
	CompileCommandTokens [  2] type 1 comp 2 5:($args)
	CompileCommandTokens [  3] type 32 comp 1 5:($args)
	CompileCommandTokens [  4] type 4 comp 0 4:(args)
	CompileCommandTokens [  5] type 2 comp 1 1:(0)
	CompileCommandTokens [  6] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 34: (
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse 34: (
				tailcall my $def {*}$args
			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 2 4:($def)
	CompileCommandTokens [  5] type 32 comp 1 4:($def)
	CompileCommandTokens [  6] type 4 comp 0 3:(def)
	CompileCommandTokens [  7] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  8] type 32 comp 1 5:($args)
	CompileCommandTokens [  9] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 3: (			}
			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 19: (			next {*}$args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 4:(next)
	CompileCommandTokens [  1] type 4 comp 0 4:(next)
	CompileCommandTokens [  2] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  3] type 32 comp 1 5:($args)
	CompileCommandTokens [  4] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832adb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241040
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'tailcall'
TEBCresume ip 0x558f3823dce8 td 0x558f38241040 r 2
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
OOMethod/InitEnsembleRewrite In  -2 +2, oc 3 len 3
In  [ 0] 'my'
In  [ 1] '--default-operation'
In  [ 2] 'oo::class.Delegate'
Arg [ 0] 'my'
Arg [ 1] '-set'
Arg [ 2] 'oo::class.Delegate'
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
OOMethod/InitEnsembleRewrite push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 120: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 120: (
			set my [namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 1 comp 1 20:([namespace which my])
	CompileCommandTokens [  5] type 16 comp 0 20:([namespace which my])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 18: (namespace which my]
			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 2 comp 1 2:(my)
	CompileCommandTokens [  5] type 4 comp 0 2:(my)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 88: (			set args [lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(args)
	CompileCommandTokens [  3] type 4 comp 0 4:(args)
	CompileCommandTokens [  4] type 1 comp 1 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens [  5] type 16 comp 0 48:([lmap a $args {uplevel 1 [list $my Resolve $a]}])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 46: (lmap a $args {uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(lmap)
	CompileCommandTokens [  1] type 4 comp 0 4:(lmap)
	CompileCommandTokens [  2] type 2 comp 1 1:(a)
	CompileCommandTokens [  3] type 4 comp 0 1:(a)
	CompileCommandTokens [  4] type 1 comp 2 5:($args)
	CompileCommandTokens [  5] type 32 comp 1 5:($args)
	CompileCommandTokens [  6] type 4 comp 0 4:(args)
	CompileCommandTokens [  7] type 2 comp 1 33:({uplevel 1 [list $my Resolve $a]})
	CompileCommandTokens [  8] type 4 comp 0 31:(uplevel 1 [list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 31: (uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 31: (uplevel 1 [list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 21:([list $my Resolve $a])
	CompileCommandTokens [  5] type 16 comp 0 21:([list $my Resolve $a])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 19: (list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse 19: (list $my Resolve $a]}]
			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 3:($my)
	CompileCommandTokens [  3] type 32 comp 1 3:($my)
	CompileCommandTokens [  4] type 4 comp 0 2:(my)
	CompileCommandTokens [  5] type 2 comp 1 7:(Resolve)
	CompileCommandTokens [  6] type 4 comp 0 7:(Resolve)
	CompileCommandTokens [  7] type 1 comp 2 2:($a)
	CompileCommandTokens [  8] type 32 comp 1 2:($a)
	CompileCommandTokens [  9] type 4 comp 0 1:(a)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 27: (			tailcall my Set $args
		)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 8:(tailcall)
	CompileCommandTokens [  1] type 4 comp 0 8:(tailcall)
	CompileCommandTokens [  2] type 2 comp 1 2:(my)
	CompileCommandTokens [  3] type 4 comp 0 2:(my)
	CompileCommandTokens [  4] type 2 comp 1 3:(Set)
	CompileCommandTokens [  5] type 4 comp 0 3:(Set)
	CompileCommandTokens [  6] type 1 comp 2 5:($args)
	CompileCommandTokens [  7] type 32 comp 1 5:($args)
	CompileCommandTokens [  8] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 2: (		)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832e898
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241090
TEBCresume ip 0x558f3823dce8 td 0x558f38241090 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f38241090 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'oo::class'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 713: (
        if {![string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 713: (
        if {![string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 27:({![string match ::* $name]})
	CompileCommandTokens [  3] type 4 comp 0 25:(![string match ::* $name])
	CompileCommandTokens [  4] type 2 comp 1 139:({
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        })
	CompileCommandTokens [  5] type 4 comp 0 137:(
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 134 const 0 mark 1 (1633771873, -2)
	TclCompileScript 22: (string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 22: (string match ::* $name]} {
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 5:(match)
	CompileCommandTokens [  3] type 4 comp 0 5:(match)
	CompileCommandTokens [  4] type 2 comp 1 3:(::*)
	CompileCommandTokens [  5] type 4 comp 0 3:(::*)
	CompileCommandTokens [  6] type 1 comp 2 5:($name)
	CompileCommandTokens [  7] type 32 comp 1 5:($name)
	CompileCommandTokens [  8] type 4 comp 0 4:(name)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 134 const 0 mark 2 (1633771873, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 137: (
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 137: (
            set ns [uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 2:(ns)
	CompileCommandTokens [  3] type 4 comp 0 2:(ns)
	CompileCommandTokens [  4] type 1 comp 1 31:([uplevel 1 {namespace current}])
	CompileCommandTokens [  5] type 16 comp 0 31:([uplevel 1 {namespace current}])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 29: (uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 29: (uplevel 1 {namespace current}]
            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 2 comp 1 19:({namespace current})
	CompileCommandTokens [  5] type 4 comp 0 17:(namespace current)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 85: (            if {$ns eq "::"} {set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 13:({$ns eq "::"})
	CompileCommandTokens [  3] type 4 comp 0 11:($ns eq "::")
	CompileCommandTokens [  4] type 2 comp 1 11:({set ns ""})
	CompileCommandTokens [  5] type 4 comp 0 9:(set ns "")
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 86 const 0 mark 0 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 86 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 9: (set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 9: (set ns ""}
            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 2:(ns)
	CompileCommandTokens [  3] type 4 comp 0 2:(ns)
	CompileCommandTokens [  4] type 2 comp 1 2:("")
	CompileCommandTokens [  5] type 4 comp 0 0:()
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 44: (            set name ${ns}::${name}
        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(name)
	CompileCommandTokens [  3] type 4 comp 0 4:(name)
	CompileCommandTokens [  4] type 1 comp 5 14:(${ns}::${name})
	CompileCommandTokens [  5] type 32 comp 1 5:(${ns})
	CompileCommandTokens [  6] type 4 comp 0 2:(ns)
	CompileCommandTokens [  7] type 4 comp 0 2:(::)
	CompileCommandTokens [  8] type 32 comp 1 7:(${name})
	CompileCommandTokens [  9] type 4 comp 0 4:(name)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 8: (        }
        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 533: (        if {[string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 33:({[string match *.Delegate $name]})
	CompileCommandTokens [  3] type 4 comp 0 31:([string match *.Delegate $name])
	CompileCommandTokens [  4] type 2 comp 1 52:({
            return [next $name {*}$args]
        })
	CompileCommandTokens [  5] type 4 comp 0 50:(
            return [next $name {*}$args]
        )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, -2)
	TclCompileScript 29: (string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 29: (string match *.Delegate $name]} {
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 6:(string)
	CompileCommandTokens [  1] type 4 comp 0 6:(string)
	CompileCommandTokens [  2] type 2 comp 1 5:(match)
	CompileCommandTokens [  3] type 4 comp 0 5:(match)
	CompileCommandTokens [  4] type 2 comp 1 10:(*.Delegate)
	CompileCommandTokens [  5] type 4 comp 0 10:(*.Delegate)
	CompileCommandTokens [  6] type 1 comp 2 5:($name)
	CompileCommandTokens [  7] type 32 comp 1 5:($name)
	CompileCommandTokens [  8] type 4 comp 0 4:(name)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, -2)
		TclCompileExpr /done
	TclCompileScript 50: (
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 50: (
            return [next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens [  2] type 1 comp 1 21:([next $name {*}$args])
	CompileCommandTokens [  3] type 16 comp 0 21:([next $name {*}$args])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 19: (next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 19: (next $name {*}$args]
        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(next)
	CompileCommandTokens [  1] type 4 comp 0 4:(next)
	CompileCommandTokens [  2] type 1 comp 2 5:($name)
	CompileCommandTokens [  3] type 32 comp 1 5:($name)
	CompileCommandTokens [  4] type 4 comp 0 4:(name)
	CompileCommandTokens [  5] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  6] type 32 comp 1 5:($args)
	CompileCommandTokens [  7] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 8: (        }
        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 435: (        set delegate [oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 8:(delegate)
	CompileCommandTokens [  3] type 4 comp 0 8:(delegate)
	CompileCommandTokens [  4] type 1 comp 1 33:([oo::class create $name.Delegate])
	CompileCommandTokens [  5] type 16 comp 0 33:([oo::class create $name.Delegate])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 31: (oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 31: (oo::class create $name.Delegate]
        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 9:(oo::class)
	CompileCommandTokens [  1] type 4 comp 0 9:(oo::class)
	CompileCommandTokens [  2] type 2 comp 1 6:(create)
	CompileCommandTokens [  3] type 4 comp 0 6:(create)
	CompileCommandTokens [  4] type 1 comp 3 14:($name.Delegate)
	CompileCommandTokens [  5] type 32 comp 1 5:($name)
	CompileCommandTokens [  6] type 4 comp 0 4:(name)
	CompileCommandTokens [  7] type 4 comp 0 9:(.Delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 380: (        set cls [next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(cls)
	CompileCommandTokens [  3] type 4 comp 0 3:(cls)
	CompileCommandTokens [  4] type 1 comp 1 21:([next $name {*}$args])
	CompileCommandTokens [  5] type 16 comp 0 21:([next $name {*}$args])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 19: (next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 19: (next $name {*}$args]
        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(next)
	CompileCommandTokens [  1] type 4 comp 0 4:(next)
	CompileCommandTokens [  2] type 1 comp 2 5:($name)
	CompileCommandTokens [  3] type 32 comp 1 5:($name)
	CompileCommandTokens [  4] type 4 comp 0 4:(name)
	CompileCommandTokens [  5] type 256 comp 2 8:({*}$args)
	CompileCommandTokens [  6] type 32 comp 1 5:($args)
	CompileCommandTokens [  7] type 4 comp 0 4:(args)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 342: (        set superdelegates [list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 14:(superdelegates)
	CompileCommandTokens [  3] type 4 comp 0 14:(superdelegates)
	CompileCommandTokens [  4] type 1 comp 1 16:([list $delegate])
	CompileCommandTokens [  5] type 16 comp 0 16:([list $delegate])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 14: (list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 14: (list $delegate]
        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 1 comp 2 9:($delegate)
	CompileCommandTokens [  3] type 32 comp 1 9:($delegate)
	CompileCommandTokens [  4] type 4 comp 0 8:(delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 298: (        foreach c [info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 7:(foreach)
	CompileCommandTokens [  1] type 4 comp 0 7:(foreach)
	CompileCommandTokens [  2] type 2 comp 1 1:(c)
	CompileCommandTokens [  3] type 4 comp 0 1:(c)
	CompileCommandTokens [  4] type 1 comp 1 28:([info class superclass $cls])
	CompileCommandTokens [  5] type 16 comp 0 28:([info class superclass $cls])
	CompileCommandTokens [  6] type 2 comp 1 174:({
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        })
	CompileCommandTokens [  7] type 4 comp 0 172:(
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 26: (info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 26: (info class superclass $cls] {
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 5:(class)
	CompileCommandTokens [  3] type 4 comp 0 5:(class)
	CompileCommandTokens [  4] type 2 comp 1 10:(superclass)
	CompileCommandTokens [  5] type 4 comp 0 10:(superclass)
	CompileCommandTokens [  6] type 1 comp 2 4:($cls)
	CompileCommandTokens [  7] type 32 comp 1 4:($cls)
	CompileCommandTokens [  8] type 4 comp 0 3:(cls)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	TclCompileScript 172: (
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 172: (
            set d $c.Delegate
            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 1:(d)
	CompileCommandTokens [  3] type 4 comp 0 1:(d)
	CompileCommandTokens [  4] type 1 comp 3 11:($c.Delegate)
	CompileCommandTokens [  5] type 32 comp 1 2:($c)
	CompileCommandTokens [  6] type 4 comp 0 1:(c)
	CompileCommandTokens [  7] type 4 comp 0 9:(.Delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 141: (            if {[info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 59:({[info object isa object $d] && [info object isa class $d]})
	CompileCommandTokens [  3] type 4 comp 0 57:([info object isa object $d] && [info object isa class $d])
	CompileCommandTokens [  4] type 2 comp 1 57:({
                lappend superdelegates $d
            })
	CompileCommandTokens [  5] type 4 comp 0 55:(
                lappend superdelegates $d
            )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 84 const 0 mark 0 (-2, -2)
	TclCompileScript 25: (info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 25: (info object isa object $d] && [info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 6:(object)
	CompileCommandTokens [  7] type 4 comp 0 6:(object)
	CompileCommandTokens [  8] type 1 comp 2 2:($d)
	CompileCommandTokens [  9] type 32 comp 1 2:($d)
	CompileCommandTokens [ 10] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 1 (-2, -2)
	TclCompileScript 24: (info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 24: (info object isa class $d]} {
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 2:($d)
	CompileCommandTokens [  9] type 32 comp 1 2:($d)
	CompileCommandTokens [ 10] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 55: (
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse 55: (
                lappend superdelegates $d
            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 7:(lappend)
	CompileCommandTokens [  1] type 4 comp 0 7:(lappend)
	CompileCommandTokens [  2] type 2 comp 1 14:(superdelegates)
	CompileCommandTokens [  3] type 4 comp 0 14:(superdelegates)
	CompileCommandTokens [  4] type 1 comp 2 2:($d)
	CompileCommandTokens [  5] type 32 comp 1 2:($d)
	CompileCommandTokens [  6] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 12: (            }
        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 8: (        }
        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 76: (        oo::objdefine $cls mixin {*}$superdelegates
        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 10
	CompileCommandTokens [  0] type 2 comp 1 13:(oo::objdefine)
	CompileCommandTokens [  1] type 4 comp 0 13:(oo::objdefine)
	CompileCommandTokens [  2] type 1 comp 2 4:($cls)
	CompileCommandTokens [  3] type 32 comp 1 4:($cls)
	CompileCommandTokens [  4] type 4 comp 0 3:(cls)
	CompileCommandTokens [  5] type 2 comp 1 5:(mixin)
	CompileCommandTokens [  6] type 4 comp 0 5:(mixin)
	CompileCommandTokens [  7] type 256 comp 2 18:({*}$superdelegates)
	CompileCommandTokens [  8] type 32 comp 1 15:($superdelegates)
	CompileCommandTokens [  9] type 4 comp 0 14:(superdelegates)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 24: (        return $cls
    )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens [  2] type 1 comp 2 4:($cls)
	CompileCommandTokens [  3] type 32 comp 1 4:($cls)
	CompileCommandTokens [  4] type 4 comp 0 3:(cls)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    )
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3839d688
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240fc0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'oo::class'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3839d688
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241260
TEBCresume ip 0x558f3823dce8 td 0x558f38241260 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'next'
TclNRNewObjectInstance
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
TclNRNewObjectInstance push clear root
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241260 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'next'
TclNRNewObjectInstance
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
TclNRNewObjectInstance push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::define'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 50: (
    classmethod validate {x} { expr {$z <= -1} }
)
	TclCompileScript parse 50: (
    classmethod validate {x} { expr {$z <= -1} }
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 11:(classmethod)
	CompileCommandTokens [  1] type 4 comp 0 11:(classmethod)
	CompileCommandTokens [  2] type 2 comp 1 8:(validate)
	CompileCommandTokens [  3] type 4 comp 0 8:(validate)
	CompileCommandTokens [  4] type 2 comp 1 3:({x})
	CompileCommandTokens [  5] type 4 comp 0 1:(x)
	CompileCommandTokens [  6] type 2 comp 1 19:({ expr {$z <= -1} })
	CompileCommandTokens [  7] type 4 comp 0 17:( expr {$z <= -1} )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a5f18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382410f0
TEBCresume ip 0x558f3823dce8 td 0x558f382410f0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'classmethod'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 670: (
    # Create the method on the class if the caller gave arguments and body
    set argc [llength [info level 0]]
    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 670: (
    # Create the method on the class if the caller gave arguments and body
    set argc [llength [info level 0]]
    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 4:(argc)
	CompileCommandTokens [  3] type 4 comp 0 4:(argc)
	CompileCommandTokens [  4] type 1 comp 1 24:([llength [info level 0]])
	CompileCommandTokens [  5] type 16 comp 0 24:([llength [info level 0]])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 22: (llength [info level 0]]
    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 22: (llength [info level 0]]
    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 7:(llength)
	CompileCommandTokens [  1] type 4 comp 0 7:(llength)
	CompileCommandTokens [  2] type 1 comp 1 14:([info level 0])
	CompileCommandTokens [  3] type 16 comp 0 14:([info level 0])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 12: (info level 0]]
    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 12: (info level 0]]
    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 5:(level)
	CompileCommandTokens [  3] type 4 comp 0 5:(level)
	CompileCommandTokens [  4] type 2 comp 1 1:(0)
	CompileCommandTokens [  5] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 556: (    if {$argc == 3} {
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 12:({$argc == 3})
	CompileCommandTokens [  3] type 4 comp 0 10:($argc == 3)
	CompileCommandTokens [  4] type 2 comp 1 107:({
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    })
	CompileCommandTokens [  5] type 4 comp 0 105:(
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 82 const 0 mark 0 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 105: (
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 105: (
        return -code error "wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 12
	CompileCommandTokens [  0] type 2 comp 1 6:(return)
	CompileCommandTokens [  1] type 4 comp 0 6:(return)
	CompileCommandTokens [  2] type 2 comp 1 5:(-code)
	CompileCommandTokens [  3] type 4 comp 0 5:(-code)
	CompileCommandTokens [  4] type 2 comp 1 5:(error)
	CompileCommandTokens [  5] type 4 comp 0 5:(error)
	CompileCommandTokens [  6] type 1 comp 5 72:("wrong # args: should be \"[lindex [info level 0] 0] name ?args body?\"")
	CompileCommandTokens [  7] type 4 comp 0 24:(wrong # args: should be )
	CompileCommandTokens [  8] type 8 comp 0 2:(\")
	CompileCommandTokens [  9] type 16 comp 0 25:([lindex [info level 0] 0])
	CompileCommandTokens [ 10] type 4 comp 0 17:( name ?args body?)
	CompileCommandTokens [ 11] type 8 comp 0 2:(\")
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 23: (lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 23: (lindex [info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(lindex)
	CompileCommandTokens [  1] type 4 comp 0 6:(lindex)
	CompileCommandTokens [  2] type 1 comp 1 14:([info level 0])
	CompileCommandTokens [  3] type 16 comp 0 14:([info level 0])
	CompileCommandTokens [  4] type 2 comp 1 1:(0)
	CompileCommandTokens [  5] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 12: (info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 12: (info level 0] 0] name ?args body?\""
    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 5:(level)
	CompileCommandTokens [  3] type 4 comp 0 5:(level)
	CompileCommandTokens [  4] type 2 comp 1 1:(0)
	CompileCommandTokens [  5] type 4 comp 0 1:(0)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }

    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 428: (
    # Get the name of the current class or class delegate 
    set cls [namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(cls)
	CompileCommandTokens [  3] type 4 comp 0 3:(cls)
	CompileCommandTokens [  4] type 1 comp 1 44:([namespace which [lindex [info level -1] 1]])
	CompileCommandTokens [  5] type 16 comp 0 44:([namespace which [lindex [info level -1] 1]])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 42: (namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 42: (namespace which [lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 5:(which)
	CompileCommandTokens [  3] type 4 comp 0 5:(which)
	CompileCommandTokens [  4] type 1 comp 1 26:([lindex [info level -1] 1])
	CompileCommandTokens [  5] type 16 comp 0 26:([lindex [info level -1] 1])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 24: (lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 24: (lindex [info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 6:(lindex)
	CompileCommandTokens [  1] type 4 comp 0 6:(lindex)
	CompileCommandTokens [  2] type 1 comp 1 15:([info level -1])
	CompileCommandTokens [  3] type 16 comp 0 15:([info level -1])
	CompileCommandTokens [  4] type 2 comp 1 1:(1)
	CompileCommandTokens [  5] type 4 comp 0 1:(1)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 13: (info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 13: (info level -1] 1]]
    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 5:(level)
	CompileCommandTokens [  3] type 4 comp 0 5:(level)
	CompileCommandTokens [  4] type 2 comp 1 2:(-1)
	CompileCommandTokens [  5] type 4 comp 0 2:(-1)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 311: (    set d $cls.Delegate
    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 1:(d)
	CompileCommandTokens [  3] type 4 comp 0 1:(d)
	CompileCommandTokens [  4] type 1 comp 3 13:($cls.Delegate)
	CompileCommandTokens [  5] type 32 comp 1 4:($cls)
	CompileCommandTokens [  6] type 4 comp 0 3:(cls)
	CompileCommandTokens [  7] type 4 comp 0 9:(.Delegate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 287: (    if {[info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 59:({[info object isa object $d] && [info object isa class $d]})
	CompileCommandTokens [  3] type 4 comp 0 57:([info object isa object $d] && [info object isa class $d])
	CompileCommandTokens [  4] type 2 comp 1 26:({
        set cls $d
    })
	CompileCommandTokens [  5] type 4 comp 0 24:(
        set cls $d
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 84 const 0 mark 0 (-2, -2)
	TclCompileScript 25: (info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 25: (info object isa object $d] && [info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 6:(object)
	CompileCommandTokens [  7] type 4 comp 0 6:(object)
	CompileCommandTokens [  8] type 1 comp 2 2:($d)
	CompileCommandTokens [  9] type 32 comp 1 2:($d)
	CompileCommandTokens [ 10] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 1 (-2, -2)
	TclCompileScript 24: (info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 24: (info object isa class $d]} {
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 11
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 3:(isa)
	CompileCommandTokens [  5] type 4 comp 0 3:(isa)
	CompileCommandTokens [  6] type 2 comp 1 5:(class)
	CompileCommandTokens [  7] type 4 comp 0 5:(class)
	CompileCommandTokens [  8] type 1 comp 2 2:($d)
	CompileCommandTokens [  9] type 32 comp 1 2:($d)
	CompileCommandTokens [ 10] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
CompileExprTree Processing @1 (lex 84 const 0 mark 2 (-2, -2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 24: (
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 24: (
        set cls $d
    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 7
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 3:(cls)
	CompileCommandTokens [  3] type 4 comp 0 3:(cls)
	CompileCommandTokens [  4] type 1 comp 2 2:($d)
	CompileCommandTokens [  5] type 32 comp 1 2:($d)
	CompileCommandTokens [  6] type 4 comp 0 1:(d)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }

    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 193: (
    if {$argc == 4} {
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 2:(if)
	CompileCommandTokens [  1] type 4 comp 0 2:(if)
	CompileCommandTokens [  2] type 2 comp 1 12:({$argc == 4})
	CompileCommandTokens [  3] type 4 comp 0 10:($argc == 4)
	CompileCommandTokens [  4] type 2 comp 1 56:({
        oo::define $cls method $name $args $body
    })
	CompileCommandTokens [  5] type 4 comp 0 54:(
        oo::define $cls method $name $args $body
    )
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 82 const 0 mark 0 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 1 (-2, -3)
CompileExprTree Processing @1 (lex 82 const 0 mark 2 (-2, -3)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	TclCompileScript 54: (
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 54: (
        oo::define $cls method $name $args $body
    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 6 tokens 16
	CompileCommandTokens [  0] type 2 comp 1 10:(oo::define)
	CompileCommandTokens [  1] type 4 comp 0 10:(oo::define)
	CompileCommandTokens [  2] type 1 comp 2 4:($cls)
	CompileCommandTokens [  3] type 32 comp 1 4:($cls)
	CompileCommandTokens [  4] type 4 comp 0 3:(cls)
	CompileCommandTokens [  5] type 2 comp 1 6:(method)
	CompileCommandTokens [  6] type 4 comp 0 6:(method)
	CompileCommandTokens [  7] type 1 comp 2 5:($name)
	CompileCommandTokens [  8] type 32 comp 1 5:($name)
	CompileCommandTokens [  9] type 4 comp 0 4:(name)
	CompileCommandTokens [ 10] type 1 comp 2 5:($args)
	CompileCommandTokens [ 11] type 32 comp 1 5:($args)
	CompileCommandTokens [ 12] type 4 comp 0 4:(args)
	CompileCommandTokens [ 13] type 1 comp 2 5:($body)
	CompileCommandTokens [ 14] type 32 comp 1 5:($body)
	CompileCommandTokens [ 15] type 4 comp 0 4:(body)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    }

    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 115: (
    # Make the connection by forwarding
    uplevel 1 [list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 7:(uplevel)
	CompileCommandTokens [  1] type 4 comp 0 7:(uplevel)
	CompileCommandTokens [  2] type 2 comp 1 1:(1)
	CompileCommandTokens [  3] type 4 comp 0 1:(1)
	CompileCommandTokens [  4] type 1 comp 1 59:([list forward $name [info object namespace $cls]::my $name])
	CompileCommandTokens [  5] type 16 comp 0 59:([list forward $name [info object namespace $cls]::my $name])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	TclCompileScript 57: (list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse 57: (list forward $name [info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 5 tokens 13
	CompileCommandTokens [  0] type 2 comp 1 4:(list)
	CompileCommandTokens [  1] type 4 comp 0 4:(list)
	CompileCommandTokens [  2] type 2 comp 1 7:(forward)
	CompileCommandTokens [  3] type 4 comp 0 7:(forward)
	CompileCommandTokens [  4] type 1 comp 2 5:($name)
	CompileCommandTokens [  5] type 32 comp 1 5:($name)
	CompileCommandTokens [  6] type 4 comp 0 4:(name)
	CompileCommandTokens [  7] type 1 comp 2 32:([info object namespace $cls]::my)
	CompileCommandTokens [  8] type 16 comp 0 28:([info object namespace $cls])
	CompileCommandTokens [  9] type 4 comp 0 4:(::my)
	CompileCommandTokens [ 10] type 1 comp 2 5:($name)
	CompileCommandTokens [ 11] type 32 comp 1 5:($name)
	CompileCommandTokens [ 12] type 4 comp 0 4:(name)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 26: (info object namespace $cls]::my $name]
)
	TclCompileScript parse 26: (info object namespace $cls]::my $name]
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 4 tokens 9
	CompileCommandTokens [  0] type 2 comp 1 4:(info)
	CompileCommandTokens [  1] type 4 comp 0 4:(info)
	CompileCommandTokens [  2] type 2 comp 1 6:(object)
	CompileCommandTokens [  3] type 4 comp 0 6:(object)
	CompileCommandTokens [  4] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  5] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  6] type 1 comp 2 4:($cls)
	CompileCommandTokens [  7] type 32 comp 1 4:($cls)
	CompileCommandTokens [  8] type 4 comp 0 3:(cls)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383847a8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241270
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 6 cmd 'oo::define'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd '::oo::define::method'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'forward'
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f382410f0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::MixinClassDelegates'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38334a08
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241140
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241270
TEBCresume ip 0x558f3823dce8 td 0x558f38241270 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::InfoClass::superclasses'
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'DelegateName'
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38315d18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241280
TEBCresume ip 0x558f3823dce8 td 0x558f38241280 r 0
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TEBCresume
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::InfoObject::isa'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 5 cmd 'objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::objdefine::mixin'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38330cb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241420
TEBCresume ip 0x558f3823dce8 td 0x558f38241420 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f38241420 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f38241420 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38241140 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::InfoClass::superclasses'
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'oo::objdefine'
MagicDefinitionInvoke
TclInitRewriteEnsemble In  -3 +1 root 1
TclInitRewriteEnsemble Out -3 +1 root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::oo::objdefine::mixin'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832adb8
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241280
TEBCresume ip 0x558f3823dce8 td 0x558f38241280 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'tailcall'
TEBCresume ip 0x558f3823dce8 td 0x558f38241280 r 2
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
OOMethod/InitEnsembleRewrite In  -2 +2, oc 3 len 3
In  [ 0] 'my'
In  [ 1] '--default-operation'
In  [ 2] '::x::point.Delegate'
Arg [ 0] 'my'
Arg [ 1] '-set'
Arg [ 2] '::x::point.Delegate'
TclInitRewriteEnsemble In  -2 +2 root 1
TclInitRewriteEnsemble Out -2 +2 root 1
OOMethod/InitEnsembleRewrite push clear root
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3832e898
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f382412d0
TEBCresume ip 0x558f3823dce8 td 0x558f382412d0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'uplevel'
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::oo::Obj9::my'
TEBCresume ip 0x558f3823dce8 td 0x558f382412d0 r 0
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'my'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
MagicDefinitionInvoke reset root
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240fc0 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 4 cmd 'namespace'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd '::tcl::namespace::eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 58: (
    namespace export point
    namespace ensemble create
)
	TclCompileScript parse 58: (
    namespace export point
    namespace ensemble create
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 6:(export)
	CompileCommandTokens [  3] type 4 comp 0 6:(export)
	CompileCommandTokens [  4] type 2 comp 1 5:(point)
	CompileCommandTokens [  5] type 4 comp 0 5:(point)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 30: (    namespace ensemble create
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 9:(namespace)
	CompileCommandTokens [  1] type 4 comp 0 9:(namespace)
	CompileCommandTokens [  2] type 2 comp 1 8:(ensemble)
	CompileCommandTokens [  3] type 4 comp 0 8:(ensemble)
	CompileCommandTokens [  4] type 2 comp 1 6:(create)
	CompileCommandTokens [  5] type 4 comp 0 6:(create)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38339348
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e30
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::export'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TEBCresume
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
TEBCresume push clear root
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::tcl::namespace::ensemble'
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e30 r 0
TclClearRootEnsemble 0
TclResetRewriteEnsemble root 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'e'
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 152: (
    set c [catch {
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse 152: (
    set c [catch {
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 3:(set)
	CompileCommandTokens [  1] type 4 comp 0 3:(set)
	CompileCommandTokens [  2] type 2 comp 1 1:(c)
	CompileCommandTokens [  3] type 4 comp 0 1:(c)
	CompileCommandTokens [  4] type 1 comp 1 125:([catch {
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m])
	CompileCommandTokens [  5] type 16 comp 0 125:([catch {
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m])
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 123: (catch {
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse 123: (catch {
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 5:(catch)
	CompileCommandTokens [  1] type 4 comp 0 5:(catch)
	CompileCommandTokens [  2] type 2 comp 1 115:({
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    })
	CompileCommandTokens [  3] type 4 comp 0 113:(
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    )
	CompileCommandTokens [  4] type 2 comp 1 1:(m)
	CompileCommandTokens [  5] type 4 comp 0 1:(m)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
	TclCompileScript 113: (
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse 113: (
	puts ________________________________________________________________/////////
	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 4:(puts)
	CompileCommandTokens [  1] type 4 comp 0 4:(puts)
	CompileCommandTokens [  2] type 2 comp 1 73:(________________________________________________________________/////////)
	CompileCommandTokens [  3] type 4 comp 0 73:(________________________________________________________________/////////)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 32: (	flush stdout
	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 5:(flush)
	CompileCommandTokens [  1] type 4 comp 0 5:(flush)
	CompileCommandTokens [  2] type 2 comp 1 6:(stdout)
	CompileCommandTokens [  3] type 4 comp 0 6:(stdout)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 18: (	eval $script
    } m]
    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 5
	CompileCommandTokens [  0] type 2 comp 1 4:(eval)
	CompileCommandTokens [  1] type 4 comp 0 4:(eval)
	CompileCommandTokens [  2] type 1 comp 2 7:($script)
	CompileCommandTokens [  3] type 32 comp 1 7:($script)
	CompileCommandTokens [  4] type 4 comp 0 6:(script)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 4: (    } m]
    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - empty
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript parse 15: (    puts $c/$m
)
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 8
	CompileCommandTokens [  0] type 2 comp 1 4:(puts)
	CompileCommandTokens [  1] type 4 comp 0 4:(puts)
	CompileCommandTokens [  2] type 1 comp 5 5:($c/$m)
	CompileCommandTokens [  3] type 32 comp 1 2:($c)
	CompileCommandTokens [  4] type 4 comp 0 1:(c)
	CompileCommandTokens [  5] type 4 comp 0 1:(/)
	CompileCommandTokens [  6] type 32 comp 1 2:($m)
	CompileCommandTokens [  7] type 4 comp 0 1:(m)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383a6a18
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240e70
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'puts'
________________________________________________________________/////////
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'flush'
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'eval'
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 18: ( x point validate )
	TclCompileScript parse 18: ( x point validate )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 3 tokens 6
	CompileCommandTokens [  0] type 2 comp 1 1:(x)
	CompileCommandTokens [  1] type 4 comp 0 1:(x)
	CompileCommandTokens [  2] type 2 comp 1 5:(point)
	CompileCommandTokens [  3] type 4 comp 0 5:(point)
	CompileCommandTokens [  4] type 2 comp 1 8:(validate)
	CompileCommandTokens [  5] type 4 comp 0 8:(validate)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - On Error
	CompileCommandTokens - TclCompileInvocation
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f3831e878
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38240f00
TEBCresume ip 0x558f3823dce8 td 0x558f38240f00 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 3 cmd 'x'
NsEnsembleImplementationCmdNR rewrite
TclInitRewriteEnsemble In  -2 +1 root 1
TclInitRewriteEnsemble Out -2 +1 root 1
NsEnsembleImplementationCmdNR push clear root
NsEnsembleImplementationCmdNR Eval
TclNREvalObjv push EvalObjvCore
NsEnsembleImplementationCmdNR Eval Done 0
EvalObjvCore
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd '::x::point'
PushMethodCallFrame A
PushMethodCallFrame B
PushMethodCallFrame C
PushMethodCallFrame D
TclProcCompileProc A
TclProcCompileProc B
TclProcCompileProc C
TclProcCompileProc G
TclProcCompileProc H
TclProcCompileProc I
TclProcCompileProc K
TclProcCompileProc L
TclSetByteCodeFromAny 1
TclSetByteCodeFromAny 2 ________________________________
	TclCompileScript 17: ( expr {$z <= -1} )
	TclCompileScript parse 17: ( expr {$z <= -1} )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 4:(expr)
	CompileCommandTokens [  1] type 4 comp 0 4:(expr)
	CompileCommandTokens [  2] type 2 comp 1 10:({$z <= -1})
	CompileCommandTokens [  3] type 4 comp 0 8:($z <= -1)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 80 const 0 mark 0 (-2, 2)
CompileExprTree Processing @1 (lex 80 const 0 mark 1 (-2, 2)
	ExecConstantExprTree - compile
CompileExprTree Processing @0 (lex 130 const 1 mark 1 (1633771873, -3)
CompileExprTree Processing @0 (lex 130 const 1 mark 2 (1633771873, -3)
	ExecConstantExprTree - run
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f38388698
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241350
	ExecConstantExprTree - done
TEBCresume ip 0x558f3823dce8 td 0x558f38241350 r 0
CompileExprTree Processing @1 (lex 80 const 0 mark 2 (-2, 2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 3 ________________________________
TclSetByteCodeFromAny 9
TclSetByteCodeFromAny 10
	TclCompileScript 17: ( expr {$z <= -1} )
	TclCompileScript parse 17: ( expr {$z <= -1} )
	TclCompileScript parse - advance
	TclCompileScript parse - compile tokens
	CompileCommandTokens words 2 tokens 4
	CompileCommandTokens [  0] type 2 comp 1 4:(expr)
	CompileCommandTokens [  1] type 4 comp 0 4:(expr)
	CompileCommandTokens [  2] type 2 comp 1 10:({$z <= -1})
	CompileCommandTokens [  3] type 4 comp 0 8:($z <= -1)
	CompileCommandTokens - EnterCmdStart
	CompileCommandTokens - EnterCmdWord
	CompileCommandTokens - CompileCmdCompileProc
		TclCompileExpr
		TclCompileExpr - parsed
		TclCompileExpr - CompileExprTree
CompileExprTree Processing @0 (lex 132 const 0 mark 1 (1633771873, 1)
CompileExprTree Processing @1 (lex 80 const 0 mark 0 (-2, 2)
CompileExprTree Processing @1 (lex 80 const 0 mark 1 (-2, 2)
	ExecConstantExprTree - compile
CompileExprTree Processing @0 (lex 130 const 1 mark 1 (1633771873, -3)
CompileExprTree Processing @0 (lex 130 const 1 mark 2 (1633771873, -3)
	ExecConstantExprTree - run
TclNRExecuteByteCode ip 0x558f3823dce8 code 0x558f383ae078
TclNRExecuteByteCode reset
TclResetRewriteEnsemble root 1
TclNRExecuteByteCode - push TEBCresume TD 0x558f38241350
	ExecConstantExprTree - done
TEBCresume ip 0x558f3823dce8 td 0x558f38241350 r 0
CompileExprTree Processing @1 (lex 80 const 0 mark 2 (-2, 2)
CompileExprTree Processing @0 (lex 132 const 0 mark 2 (1633771873, 1)
		TclCompileExpr /done
	CompileCommandTokens - EnterCmdExtend
	CompileCommandTokens /done
	TclCompileScript parse - advance 2
	TclCompileScript parse /iter
	TclCompileScript /parse
	TclCompileScript /done
TclSetByteCodeFromAny 11
TclSetByteCodeFromAny 4 ________________________________
TclSetByteCodeFromAny 5
TclSetByteCodeFromAny 6
TclSetByteCodeFromAny 7
TclSetByteCodeFromAny 8
TclProcCompileProc J
TclProcCompileProc E
PushMethodCallFrame E
PushMethodCallFrame F
PushMethodCallFrame G
InitArgsAndLocals, incorrect, skip 2
TclInitRewriteEnsemble In  -1 +0 root 1
TclInitRewriteEnsemble Out -1 +0 root 1
InitArgsAndLocals push clear root
Tcl_WrongNumArgs(2) '(null)'
in.... [ 0] 'validate'
in.... [ 1] 'x'
Tcl_WrongNumArgs WA
Tcl_WrongNumArgs Ensemble
Tcl_WrongNumArgs 2 skip 0 print 1
skippd [ 0] 'validate'
skippd [ 1] 'x'
Tcl_WrongNumArgs +Arguments
Tcl_WrongNumArgs +Trailer
Tcl_WrongNumArgs Done
TclClearRootEnsemble 1
TclResetRewriteEnsemble root 1
TclClearRootEnsemble 1
TclResetRewriteEnsemble root 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240f00 r 1
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 1
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'puts'
1/wrong # args: should be "::x::point validate x"
TEBCresume ip 0x558f3823dce8 td 0x558f38240e70 r 0
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 2 cmd 'puts'
done
TclNREvalObjv push NRCommand
TclNREvalObjv push EvalObjvCore
EvalObjvCore
EvalObjvCore reset
TclResetRewriteEnsemble root 1
EvalObjvCore push Dispatch
Dispatch
Dispatch objProc oc 1 cmd 'exit'
